checkpoint- remove dependencies on gl_texture_format to make code re-usable by state tracker

1 files changed, 266 insertions, 158 deletions

diff --git a/src/mesa/main/mipmap.c b/src/mesa/main/mipmap.c
index 1e61829e8f1..013dc3752ec 100644
--- a/src/mesa/main/mipmap.c
+++ b/src/mesa/main/mipmap.c
@@ -36,27 +36,205 @@
 
 
 
+static GLint
+bytes_per_pixel(GLenum datatype, GLuint comps)
+{
+   GLint b = _mesa_sizeof_packed_type(datatype);
+   assert(b >= 0);
+   return b * comps;
+}
+
+
+static void
+mesa_format_to_type_and_comps(const struct gl_texture_format *format,
+                              GLenum *datatype, GLuint *comps)
+{
+   switch (format->MesaFormat) {
+   case MESA_FORMAT_RGBA8888:
+   case MESA_FORMAT_RGBA8888_REV:
+   case MESA_FORMAT_ARGB8888:
+   case MESA_FORMAT_ARGB8888_REV:
+      *datatype = CHAN_TYPE;
+      *comps = 4;
+      return;
+   case MESA_FORMAT_RGB888:
+   case MESA_FORMAT_BGR888:
+      *datatype = GL_UNSIGNED_BYTE;
+      *comps = 3;
+      return;
+   case MESA_FORMAT_RGB565:
+   case MESA_FORMAT_RGB565_REV:
+      *datatype = GL_UNSIGNED_SHORT_5_6_5;
+      *comps = 3;
+      return;
+
+   case MESA_FORMAT_ARGB4444:
+   case MESA_FORMAT_ARGB4444_REV:
+      *datatype = GL_UNSIGNED_SHORT_4_4_4_4;
+      *comps = 4;
+      return;
+
+   case MESA_FORMAT_ARGB1555:
+   case MESA_FORMAT_ARGB1555_REV:
+      *datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV;
+      *comps = 3;
+      return;
+
+   case MESA_FORMAT_AL88:
+   case MESA_FORMAT_AL88_REV:
+      *datatype = GL_UNSIGNED_BYTE;
+      *comps = 2;
+      return;
+   case MESA_FORMAT_RGB332:
+      *datatype = GL_UNSIGNED_BYTE_3_3_2;
+      *comps = 3;
+      return;
+
+   case MESA_FORMAT_A8:
+   case MESA_FORMAT_L8:
+   case MESA_FORMAT_I8:
+   case MESA_FORMAT_CI8:
+      *datatype = GL_UNSIGNED_BYTE;
+      *comps = 1;
+      return;
+
+   case MESA_FORMAT_YCBCR:
+   case MESA_FORMAT_YCBCR_REV:
+      *datatype = GL_UNSIGNED_SHORT;
+      *comps = 2;
+      return;
+
+   case MESA_FORMAT_Z24_S8:
+      *datatype = GL_UNSIGNED_INT;
+      *comps = 1; /* XXX OK? */
+      return;
+
+   case MESA_FORMAT_Z16:
+      *datatype = GL_UNSIGNED_SHORT;
+      *comps = 1;
+      return;
+
+   case MESA_FORMAT_Z32:
+      *datatype = GL_UNSIGNED_INT;
+      *comps = 1;
+      return;
+
+   case MESA_FORMAT_SRGB8:
+      *datatype = GL_UNSIGNED_BYTE;
+      *comps = 3;
+      return;
+   case MESA_FORMAT_SRGBA8:
+      *datatype = GL_UNSIGNED_BYTE;
+      *comps = 4;
+      return;
+   case MESA_FORMAT_SL8:
+      *datatype = GL_UNSIGNED_BYTE;
+      *comps = 1;
+      return;
+   case MESA_FORMAT_SLA8:
+      *datatype = GL_UNSIGNED_BYTE;
+      *comps = 2;
+      return;
+
+   case MESA_FORMAT_RGB_FXT1:
+   case MESA_FORMAT_RGBA_FXT1:
+   case MESA_FORMAT_RGB_DXT1:
+   case MESA_FORMAT_RGBA_DXT1:
+   case MESA_FORMAT_RGBA_DXT3:
+   case MESA_FORMAT_RGBA_DXT5:
+      /* XXX generate error instead? */
+      *datatype = GL_UNSIGNED_BYTE;
+      *comps = 0;
+      return;
+
+   case MESA_FORMAT_RGBA:
+      *datatype = CHAN_TYPE;
+      *comps = 4;
+      return;
+   case MESA_FORMAT_RGB:
+      *datatype = CHAN_TYPE;
+      *comps = 3;
+      return;
+   case MESA_FORMAT_LUMINANCE_ALPHA:
+      *datatype = CHAN_TYPE;
+      *comps = 2;
+      return;
+   case MESA_FORMAT_ALPHA:
+   case MESA_FORMAT_LUMINANCE:
+   case MESA_FORMAT_INTENSITY:
+      *datatype = CHAN_TYPE;
+      *comps = 1;
+      return;
+
+   case MESA_FORMAT_RGBA_FLOAT32:
+      *datatype = GL_FLOAT;
+      *comps = 4;
+      return;
+   case MESA_FORMAT_RGBA_FLOAT16:
+      *datatype = GL_HALF_FLOAT_ARB;
+      *comps = 4;
+      return;
+   case MESA_FORMAT_RGB_FLOAT32:
+      *datatype = GL_FLOAT;
+      *comps = 3;
+      return;
+   case MESA_FORMAT_RGB_FLOAT16:
+      *datatype = GL_HALF_FLOAT_ARB;
+      *comps = 3;
+      return;
+   case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32:
+      *datatype = GL_FLOAT;
+      *comps = 2;
+      return;
+   case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16:
+      *datatype = GL_HALF_FLOAT_ARB;
+      *comps = 2;
+      return;
+   case MESA_FORMAT_ALPHA_FLOAT32:
+   case MESA_FORMAT_LUMINANCE_FLOAT32:
+   case MESA_FORMAT_INTENSITY_FLOAT32:
+      *datatype = GL_FLOAT;
+      *comps = 1;
+      return;
+   case MESA_FORMAT_ALPHA_FLOAT16:
+   case MESA_FORMAT_LUMINANCE_FLOAT16:
+   case MESA_FORMAT_INTENSITY_FLOAT16:
+      *datatype = GL_HALF_FLOAT_ARB;
+      *comps = 1;
+      return;
+
+   default:
+      _mesa_problem(NULL, "bad texture format in mesa_format_to_type_and_comps");
+      *datatype = 0;
+      *comps = 1;
+   }
+}
+
+
 /**
  * Average together two rows of a source image to produce a single new
  * row in the dest image.  It's legal for the two source rows to point
  * to the same data.  The source width must be equal to either the
  * dest width or two times the dest width.
+ * \param datatype  GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, GL_FLOAT, etc.
+ * \param comps  number of components per pixel (1..4)
  */
 static void
-do_row(const struct gl_texture_format *format, GLint srcWidth,
+do_row(GLenum datatype, GLuint comps, GLint srcWidth,
        const GLvoid *srcRowA, const GLvoid *srcRowB,
        GLint dstWidth, GLvoid *dstRow)
 {
    const GLuint k0 = (srcWidth == dstWidth) ? 0 : 1;
    const GLuint colStride = (srcWidth == dstWidth) ? 1 : 2;
 
+   ASSERT(comps >= 1);
+   ASSERT(comps <= 4);
+
    /* This assertion is no longer valid with non-power-of-2 textures
    assert(srcWidth == dstWidth || srcWidth == 2 * dstWidth);
    */
 
-   switch (format->MesaFormat) {
-   case MESA_FORMAT_RGBA:
-      {
+   if (datatype == CHAN_TYPE && comps == 4) {
          GLuint i, j, k;
          const GLchan (*rowA)[4] = (const GLchan (*)[4]) srcRowA;
          const GLchan (*rowB)[4] = (const GLchan (*)[4]) srcRowB;
@@ -72,10 +250,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             dst[i][3] = (rowA[j][3] + rowA[k][3] +
                          rowB[j][3] + rowB[k][3]) / 4;
          }
-      }
-      return;
-   case MESA_FORMAT_RGB:
-      {
+   }
+   else if (datatype == CHAN_TYPE && comps == 3) {
          GLuint i, j, k;
          const GLchan (*rowA)[3] = (const GLchan (*)[3]) srcRowA;
          const GLchan (*rowB)[3] = (const GLchan (*)[3]) srcRowB;
@@ -89,12 +265,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             dst[i][2] = (rowA[j][2] + rowA[k][2] +
                          rowB[j][2] + rowB[k][2]) / 4;
          }
-      }
-      return;
-   case MESA_FORMAT_ALPHA:
-   case MESA_FORMAT_LUMINANCE:
-   case MESA_FORMAT_INTENSITY:
-      {
+   }
+   else if (datatype == CHAN_TYPE && comps == 1) {
          GLuint i, j, k;
          const GLchan *rowA = (const GLchan *) srcRowA;
          const GLchan *rowB = (const GLchan *) srcRowB;
@@ -103,10 +275,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
               i++, j += colStride, k += colStride) {
             dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;
          }
-      }
-      return;
-   case MESA_FORMAT_LUMINANCE_ALPHA:
-      {
+   }
+   else if (datatype == CHAN_TYPE && comps == 2) {
          GLuint i, j, k;
          const GLchan (*rowA)[2] = (const GLchan (*)[2]) srcRowA;
          const GLchan (*rowB)[2] = (const GLchan (*)[2]) srcRowB;
@@ -118,10 +288,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             dst[i][1] = (rowA[j][1] + rowA[k][1] +
                          rowB[j][1] + rowB[k][1]) / 4;
          }
-      }
-      return;
-   case MESA_FORMAT_Z32:
-      {
+   }
+   else if (datatype == GL_UNSIGNED_INT && comps == 1) {
          GLuint i, j, k;
          const GLuint *rowA = (const GLuint *) srcRowA;
          const GLuint *rowB = (const GLuint *) srcRowB;
@@ -130,10 +298,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
               i++, j += colStride, k += colStride) {
             dst[i] = rowA[j] / 4 + rowA[k] / 4 + rowB[j] / 4 + rowB[k] / 4;
          }
-      }
-      return;
-   case MESA_FORMAT_Z16:
-      {
+   }
+   else if (datatype == GL_UNSIGNED_SHORT && comps == 1) {
          GLuint i, j, k;
          const GLushort *rowA = (const GLushort *) srcRowA;
          const GLushort *rowB = (const GLushort *) srcRowB;
@@ -142,17 +308,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
               i++, j += colStride, k += colStride) {
             dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;
          }
-      }
-      return;
-   /* Begin hardware formats */
-   case MESA_FORMAT_RGBA8888:
-   case MESA_FORMAT_RGBA8888_REV:
-   case MESA_FORMAT_ARGB8888:
-   case MESA_FORMAT_ARGB8888_REV:
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SRGBA8:
-#endif
-      {
+   }
+   else if (datatype == GL_UNSIGNED_BYTE && comps == 4) {
          GLuint i, j, k;
          const GLubyte (*rowA)[4] = (const GLubyte (*)[4]) srcRowA;
          const GLubyte (*rowB)[4] = (const GLubyte (*)[4]) srcRowB;
@@ -168,14 +325,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             dst[i][3] = (rowA[j][3] + rowA[k][3] +
                          rowB[j][3] + rowB[k][3]) / 4;
          }
-      }
-      return;
-   case MESA_FORMAT_RGB888:
-   case MESA_FORMAT_BGR888:
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SRGB8:
-#endif
-      {
+   }
+   else if (datatype == GL_UNSIGNED_BYTE && comps == 3) {
          GLuint i, j, k;
          const GLubyte (*rowA)[3] = (const GLubyte (*)[3]) srcRowA;
          const GLubyte (*rowB)[3] = (const GLubyte (*)[3]) srcRowB;
@@ -189,11 +340,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             dst[i][2] = (rowA[j][2] + rowA[k][2] +
                          rowB[j][2] + rowB[k][2]) / 4;
          }
-      }
-      return;
-   case MESA_FORMAT_RGB565:
-   case MESA_FORMAT_RGB565_REV:
-      {
+   }
+   else if (datatype == GL_UNSIGNED_SHORT_5_6_5 && comps == 3) {
          GLuint i, j, k;
          const GLushort *rowA = (const GLushort *) srcRowA;
          const GLushort *rowB = (const GLushort *) srcRowB;
@@ -217,11 +365,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             const GLint blue  = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;
             dst[i] = (blue << 11) | (green << 5) | red;
          }
-      }
-      return;
-   case MESA_FORMAT_ARGB4444:
-   case MESA_FORMAT_ARGB4444_REV:
-      {
+   }
+   else if (datatype == GL_UNSIGNED_SHORT_4_4_4_4 && comps == 4) {
          GLuint i, j, k;
          const GLushort *rowA = (const GLushort *) srcRowA;
          const GLushort *rowB = (const GLushort *) srcRowB;
@@ -250,11 +395,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 2;
             dst[i] = (alpha << 12) | (blue << 8) | (green << 4) | red;
          }
-      }
-      return;
-   case MESA_FORMAT_ARGB1555:
-   case MESA_FORMAT_ARGB1555_REV: /* XXX broken? */
-      {
+   }
+   else if (datatype == GL_UNSIGNED_SHORT_1_5_5_5_REV && comps == 4) {
          GLuint i, j, k;
          const GLushort *rowA = (const GLushort *) srcRowA;
          const GLushort *rowB = (const GLushort *) srcRowB;
@@ -283,14 +425,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 2;
             dst[i] = (alpha << 15) | (blue << 10) | (green << 5) | red;
          }
-      }
-      return;
-   case MESA_FORMAT_AL88:
-   case MESA_FORMAT_AL88_REV:
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SLA8:
-#endif
-      {
+   }
+   else if (datatype == GL_UNSIGNED_BYTE && comps == 2) {
          GLuint i, j, k;
          const GLubyte (*rowA)[2] = (const GLubyte (*)[2]) srcRowA;
          const GLubyte (*rowB)[2] = (const GLubyte (*)[2]) srcRowB;
@@ -302,10 +438,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             dst[i][1] = (rowA[j][1] + rowA[k][1] +
                          rowB[j][1] + rowB[k][1]) >> 2;
          }
-      }
-      return;
-   case MESA_FORMAT_RGB332:
-      {
+   }
+   else if (datatype == GL_UNSIGNED_BYTE_3_3_2 && comps == 3) {
          GLuint i, j, k;
          const GLubyte *rowA = (const GLubyte *) srcRowA;
          const GLubyte *rowB = (const GLubyte *) srcRowB;
@@ -329,16 +463,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             const GLint blue  = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;
             dst[i] = (blue << 5) | (green << 2) | red;
          }
-      }
-      return;
-   case MESA_FORMAT_A8:
-   case MESA_FORMAT_L8:
-   case MESA_FORMAT_I8:
-   case MESA_FORMAT_CI8:
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SL8:
-#endif
-      {
+   }
+   else if (datatype == GL_UNSIGNED_BYTE && comps == 1) {
          GLuint i, j, k;
          const GLubyte *rowA = (const GLubyte *) srcRowA;
          const GLubyte *rowB = (const GLubyte *) srcRowB;
@@ -347,10 +473,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
               i++, j += colStride, k += colStride) {
             dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) >> 2;
          }
-      }
-      return;
-   case MESA_FORMAT_RGBA_FLOAT32:
-      {
+   }
+   else if (datatype == GL_FLOAT && comps == 4) {
          GLuint i, j, k;
          const GLfloat (*rowA)[4] = (const GLfloat (*)[4]) srcRowA;
          const GLfloat (*rowB)[4] = (const GLfloat (*)[4]) srcRowB;
@@ -366,10 +490,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             dst[i][3] = (rowA[j][3] + rowA[k][3] +
                          rowB[j][3] + rowB[k][3]) * 0.25F;
          }
-      }
-      return;
-   case MESA_FORMAT_RGBA_FLOAT16:
-      {
+   }
+   else if (datatype == GL_HALF_FLOAT_ARB && comps == 4) {
          GLuint i, j, k, comp;
          const GLhalfARB (*rowA)[4] = (const GLhalfARB (*)[4]) srcRowA;
          const GLhalfARB (*rowB)[4] = (const GLhalfARB (*)[4]) srcRowB;
@@ -385,10 +507,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
                dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
             }
          }
-      }
-      return;
-   case MESA_FORMAT_RGB_FLOAT32:
-      {
+   }
+   else if (datatype == GL_FLOAT && comps == 3) {
          GLuint i, j, k;
          const GLfloat (*rowA)[3] = (const GLfloat (*)[3]) srcRowA;
          const GLfloat (*rowB)[3] = (const GLfloat (*)[3]) srcRowB;
@@ -402,10 +522,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             dst[i][2] = (rowA[j][2] + rowA[k][2] +
                          rowB[j][2] + rowB[k][2]) * 0.25F;
          }
-      }
-      return;
-   case MESA_FORMAT_RGB_FLOAT16:
-      {
+   }
+   else if (datatype == GL_HALF_FLOAT_ARB && comps == 3) {
          GLuint i, j, k, comp;
          const GLhalfARB (*rowA)[3] = (const GLhalfARB (*)[3]) srcRowA;
          const GLhalfARB (*rowB)[3] = (const GLhalfARB (*)[3]) srcRowB;
@@ -421,10 +539,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
                dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
             }
          }
-      }
-      return;
-   case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32:
-      {
+   }
+   else if (datatype == GL_FLOAT && comps == 2) {
          GLuint i, j, k;
          const GLfloat (*rowA)[2] = (const GLfloat (*)[2]) srcRowA;
          const GLfloat (*rowB)[2] = (const GLfloat (*)[2]) srcRowB;
@@ -436,10 +552,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             dst[i][1] = (rowA[j][1] + rowA[k][1] +
                          rowB[j][1] + rowB[k][1]) * 0.25F;
          }
-      }
-      return;
-   case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16:
-      {
+   }
+   else if (datatype == GL_HALF_FLOAT_ARB && comps == 2) {
          GLuint i, j, k, comp;
          const GLhalfARB (*rowA)[2] = (const GLhalfARB (*)[2]) srcRowA;
          const GLhalfARB (*rowB)[2] = (const GLhalfARB (*)[2]) srcRowB;
@@ -455,12 +569,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
                dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
             }
          }
-      }
-      return;
-   case MESA_FORMAT_ALPHA_FLOAT32:
-   case MESA_FORMAT_LUMINANCE_FLOAT32:
-   case MESA_FORMAT_INTENSITY_FLOAT32:
-      {
+   }
+   else if (datatype == GL_FLOAT && comps == 1) {
          GLuint i, j, k;
          const GLfloat *rowA = (const GLfloat *) srcRowA;
          const GLfloat *rowB = (const GLfloat *) srcRowB;
@@ -469,12 +579,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
               i++, j += colStride, k += colStride) {
             dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) * 0.25F;
          }
-      }
-      return;
-   case MESA_FORMAT_ALPHA_FLOAT16:
-   case MESA_FORMAT_LUMINANCE_FLOAT16:
-   case MESA_FORMAT_INTENSITY_FLOAT16:
-      {
+   }
+   else if (datatype == GL_HALF_FLOAT_ARB && comps == 1) {
          GLuint i, j, k;
          const GLhalfARB *rowA = (const GLhalfARB *) srcRowA;
          const GLhalfARB *rowB = (const GLhalfARB *) srcRowB;
@@ -488,10 +594,8 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
             bk = _mesa_half_to_float(rowB[k]);
             dst[i] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
          }
-      }
-      return;
-
-   default:
+   }
+   else {
       _mesa_problem(NULL, "bad format in do_row()");
    }
 }
@@ -504,11 +608,11 @@ do_row(const struct gl_texture_format *format, GLint srcWidth,
  */
 
 static void
-make_1d_mipmap(const struct gl_texture_format *format, GLint border,
+make_1d_mipmap(GLenum datatype, GLuint comps, GLint border,
                GLint srcWidth, const GLubyte *srcPtr,
                GLint dstWidth, GLubyte *dstPtr)
 {
-   const GLint bpt = format->TexelBytes;
+   const GLint bpt = bytes_per_pixel(datatype, comps);
    const GLubyte *src;
    GLubyte *dst;
 
@@ -517,7 +621,7 @@ make_1d_mipmap(const struct gl_texture_format *format, GLint border,
    dst = dstPtr + border * bpt;
 
    /* we just duplicate the input row, kind of hack, saves code */
-   do_row(format, srcWidth - 2 * border, src, src,
+   do_row(datatype, comps, srcWidth - 2 * border, src, src,
           dstWidth - 2 * border, dst);
 
    if (border) {
@@ -535,11 +639,11 @@ make_1d_mipmap(const struct gl_texture_format *format, GLint border,
  * XXX need to use the tex image's row stride!
  */
 static void
-make_2d_mipmap(const struct gl_texture_format *format, GLint border,
+make_2d_mipmap(GLenum datatype, GLuint comps, GLint border,
                GLint srcWidth, GLint srcHeight, const GLubyte *srcPtr,
                GLint dstWidth, GLint dstHeight, GLubyte *dstPtr)
 {
-   const GLint bpt = format->TexelBytes;
+   const GLint bpt = bytes_per_pixel(datatype, comps);
    const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */
    const GLint dstWidthNB = dstWidth - 2 * border;
    const GLint dstHeightNB = dstHeight - 2 * border;
@@ -558,7 +662,7 @@ make_2d_mipmap(const struct gl_texture_format *format, GLint border,
    dst = dstPtr + border * ((dstWidth + 1) * bpt);
 
    for (row = 0; row < dstHeightNB; row++) {
-      do_row(format, srcWidthNB, srcA, srcB,
+      do_row(datatype, comps, srcWidthNB, srcA, srcB,
              dstWidthNB, dst);
       srcA += 2 * srcRowStride;
       srcB += 2 * srcRowStride;
@@ -580,12 +684,12 @@ make_2d_mipmap(const struct gl_texture_format *format, GLint border,
       MEMCPY(dstPtr + (dstWidth * dstHeight - 1) * bpt,
              srcPtr + (srcWidth * srcHeight - 1) * bpt, bpt);
       /* lower border */
-      do_row(format, srcWidthNB,
+      do_row(datatype, comps, srcWidthNB,
              srcPtr + bpt,
              srcPtr + bpt,
              dstWidthNB, dstPtr + bpt);
       /* upper border */
-      do_row(format, srcWidthNB,
+      do_row(datatype, comps, srcWidthNB,
              srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
              srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
              dstWidthNB,
@@ -603,11 +707,11 @@ make_2d_mipmap(const struct gl_texture_format *format, GLint border,
       else {
          /* average two src pixels each dest pixel */
          for (row = 0; row < dstHeightNB; row += 2) {
-            do_row(format, 1,
+            do_row(datatype, comps, 1,
                    srcPtr + (srcWidth * (row * 2 + 1)) * bpt,
                    srcPtr + (srcWidth * (row * 2 + 2)) * bpt,
                    1, dstPtr + (dstWidth * row + 1) * bpt);
-            do_row(format, 1,
+            do_row(datatype, comps, 1,
                    srcPtr + (srcWidth * (row * 2 + 1) + srcWidth - 1) * bpt,
                    srcPtr + (srcWidth * (row * 2 + 2) + srcWidth - 1) * bpt,
                    1, dstPtr + (dstWidth * row + 1 + dstWidth - 1) * bpt);
@@ -618,13 +722,13 @@ make_2d_mipmap(const struct gl_texture_format *format, GLint border,
 
 
 static void
-make_3d_mipmap(const struct gl_texture_format *format, GLint border,
+make_3d_mipmap(GLenum datatype, GLuint comps, GLint border,
                GLint srcWidth, GLint srcHeight, GLint srcDepth,
                const GLubyte *srcPtr,
                GLint dstWidth, GLint dstHeight, GLint dstDepth,
                GLubyte *dstPtr)
 {
-   const GLint bpt = format->TexelBytes;
+   const GLint bpt = bytes_per_pixel(datatype, comps);
    const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */
    const GLint srcDepthNB = srcDepth - 2 * border;
    const GLint dstWidthNB = dstWidth - 2 * border;
@@ -694,13 +798,13 @@ make_3d_mipmap(const struct gl_texture_format *format, GLint border,
 
       for (row = 0; row < dstHeightNB; row++) {
          /* Average together two rows from first src image */
-         do_row(format, srcWidthNB, srcImgARowA, srcImgARowB,
+         do_row(datatype, comps, srcWidthNB, srcImgARowA, srcImgARowB,
                 srcWidthNB, tmpRowA);
          /* Average together two rows from second src image */
-         do_row(format, srcWidthNB, srcImgBRowA, srcImgBRowB,
+         do_row(datatype, comps, srcWidthNB, srcImgBRowA, srcImgBRowB,
                 srcWidthNB, tmpRowB);
          /* Average together the temp rows to make the final row */
-         do_row(format, srcWidthNB, tmpRowA, tmpRowB,
+         do_row(datatype, comps, srcWidthNB, tmpRowA, tmpRowB,
                 dstWidthNB, dstImgRow);
          /* advance to next rows */
          srcImgARowA += bytesPerSrcRow + srcRowOffset;
@@ -717,10 +821,10 @@ make_3d_mipmap(const struct gl_texture_format *format, GLint border,
    /* Luckily we can leverage the make_2d_mipmap() function here! */
    if (border > 0) {
       /* do front border image */
-      make_2d_mipmap(format, 1, srcWidth, srcHeight, srcPtr,
+      make_2d_mipmap(datatype, comps, 1, srcWidth, srcHeight, srcPtr,
                      dstWidth, dstHeight, dstPtr);
       /* do back border image */
-      make_2d_mipmap(format, 1, srcWidth, srcHeight,
+      make_2d_mipmap(datatype, comps, 1, srcWidth, srcHeight,
                      srcPtr + bytesPerSrcImage * (srcDepth - 1),
                      dstWidth, dstHeight,
                      dstPtr + bytesPerDstImage * (dstDepth - 1));
@@ -768,28 +872,28 @@ make_3d_mipmap(const struct gl_texture_format *format, GLint border,
             /* do border along [img][row=0][col=0] */
             src = srcPtr + (img * 2 + 1) * bytesPerSrcImage;
             dst = dstPtr + (img + 1) * bytesPerDstImage;
-            do_row(format, 1, src, src + srcImageOffset, 1, dst);
+            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
 
             /* do border along [img][row=dstHeight-1][col=0] */
             src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
                          + (srcHeight - 1) * bytesPerSrcRow;
             dst = dstPtr + (img + 1) * bytesPerDstImage
                          + (dstHeight - 1) * bytesPerDstRow;
-            do_row(format, 1, src, src + srcImageOffset, 1, dst);
+            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
 
             /* do border along [img][row=0][col=dstWidth-1] */
             src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
                          + (srcWidth - 1) * bpt;
             dst = dstPtr + (img + 1) * bytesPerDstImage
                          + (dstWidth - 1) * bpt;
-            do_row(format, 1, src, src + srcImageOffset, 1, dst);
+            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
 
             /* do border along [img][row=dstHeight-1][col=dstWidth-1] */
             src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
                          + (bytesPerSrcImage - bpt);
             dst = dstPtr + (img + 1) * bytesPerDstImage
                          + (bytesPerDstImage - bpt);
-            do_row(format, 1, src, src + srcImageOffset, 1, dst);
+            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
          }
       }
    }
@@ -797,11 +901,11 @@ make_3d_mipmap(const struct gl_texture_format *format, GLint border,
 
 
 static void
-make_1d_stack_mipmap(const struct gl_texture_format *format, GLint border,
+make_1d_stack_mipmap(GLenum datatype, GLuint comps, GLint border,
                      GLint srcWidth, const GLubyte *srcPtr,
                      GLint dstWidth, GLint dstHeight, GLubyte *dstPtr)
 {
-   const GLint bpt = format->TexelBytes;
+   const GLint bpt = bytes_per_pixel(datatype, comps);
    const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */
    const GLint dstWidthNB = dstWidth - 2 * border;
    const GLint dstHeightNB = dstHeight - 2 * border;
@@ -816,7 +920,7 @@ make_1d_stack_mipmap(const struct gl_texture_format *format, GLint border,
    dst = dstPtr + border * ((dstWidth + 1) * bpt);
 
    for (row = 0; row < dstHeightNB; row++) {
-      do_row(format, srcWidthNB, src, src,
+      do_row(datatype, comps, srcWidthNB, src, src,
              dstWidthNB, dst);
       src += srcRowStride;
       dst += dstRowStride;
@@ -839,12 +943,12 @@ make_1d_stack_mipmap(const struct gl_texture_format *format, GLint border,
  * and \c make_2d_mipmap.
  */
 static void
-make_2d_stack_mipmap(const struct gl_texture_format *format, GLint border,
+make_2d_stack_mipmap(GLenum datatype, GLuint comps, GLint border,
                      GLint srcWidth, GLint srcHeight, const GLubyte *srcPtr,
                      GLint dstWidth, GLint dstHeight, GLint dstDepth,
                      GLubyte *dstPtr)
 {
-   const GLint bpt = format->TexelBytes;
+   const GLint bpt = bytes_per_pixel(datatype, comps);
    const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */
    const GLint dstWidthNB = dstWidth - 2 * border;
    const GLint dstHeightNB = dstHeight - 2 * border;
@@ -866,7 +970,7 @@ make_2d_stack_mipmap(const struct gl_texture_format *format, GLint border,
 
    for (layer = 0; layer < dstDepthNB; layer++) {
       for (row = 0; row < dstHeightNB; row++) {
-         do_row(format, srcWidthNB, srcA, srcB,
+         do_row(datatype, comps, srcWidthNB, srcA, srcB,
                 dstWidthNB, dst);
          srcA += 2 * srcRowStride;
          srcB += 2 * srcRowStride;
@@ -888,12 +992,12 @@ make_2d_stack_mipmap(const struct gl_texture_format *format, GLint border,
          MEMCPY(dstPtr + (dstWidth * dstHeight - 1) * bpt,
                 srcPtr + (srcWidth * srcHeight - 1) * bpt, bpt);
          /* lower border */
-         do_row(format, srcWidthNB,
+         do_row(datatype, comps, srcWidthNB,
                 srcPtr + bpt,
                 srcPtr + bpt,
                 dstWidthNB, dstPtr + bpt);
          /* upper border */
-         do_row(format, srcWidthNB,
+         do_row(datatype, comps, srcWidthNB,
                 srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
                 srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
                 dstWidthNB,
@@ -911,11 +1015,11 @@ make_2d_stack_mipmap(const struct gl_texture_format *format, GLint border,
          else {
             /* average two src pixels each dest pixel */
             for (row = 0; row < dstHeightNB; row += 2) {
-               do_row(format, 1,
+               do_row(datatype, comps, 1,
                       srcPtr + (srcWidth * (row * 2 + 1)) * bpt,
                       srcPtr + (srcWidth * (row * 2 + 2)) * bpt,
                       1, dstPtr + (dstWidth * row + 1) * bpt);
-               do_row(format, 1,
+               do_row(datatype, comps, 1,
                       srcPtr + (srcWidth * (row * 2 + 1) + srcWidth - 1) * bpt,
                       srcPtr + (srcWidth * (row * 2 + 2) + srcWidth - 1) * bpt,
                       1, dstPtr + (dstWidth * row + 1 + dstWidth - 1) * bpt);
@@ -940,6 +1044,8 @@ _mesa_generate_mipmap(GLcontext *ctx, GLenum target,
    const GLubyte *srcData = NULL;
    GLubyte *dstData = NULL;
    GLint level, maxLevels;
+   GLenum datatype;
+   GLuint comps;
 
    ASSERT(texObj);
    /* XXX choose cube map face here??? */
@@ -1002,6 +1108,8 @@ _mesa_generate_mipmap(GLcontext *ctx, GLenum target,
       convertFormat = srcImage->TexFormat;
    }
 
+   mesa_format_to_type_and_comps(convertFormat, &datatype, &comps);
+
    for (level = texObj->BaseLevel; level < texObj->MaxLevel
            && level < maxLevels - 1; level++) {
       /* generate image[level+1] from image[level] */
@@ -1118,7 +1226,7 @@ _mesa_generate_mipmap(GLcontext *ctx, GLenum target,
        */
       switch (target) {
          case GL_TEXTURE_1D:
-            make_1d_mipmap(convertFormat, border,
+            make_1d_mipmap(datatype, comps, border,
                            srcWidth, srcData,
                            dstWidth, dstData);
             break;
@@ -1129,22 +1237,22 @@ _mesa_generate_mipmap(GLcontext *ctx, GLenum target,
          case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
          case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
          case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-            make_2d_mipmap(convertFormat, border,
+            make_2d_mipmap(datatype, comps, border,
                            srcWidth, srcHeight, srcData,
                            dstWidth, dstHeight, dstData);
             break;
          case GL_TEXTURE_3D:
-            make_3d_mipmap(convertFormat, border,
+            make_3d_mipmap(datatype, comps, border,
                            srcWidth, srcHeight, srcDepth, srcData,
                            dstWidth, dstHeight, dstDepth, dstData);
             break;
          case GL_TEXTURE_1D_ARRAY_EXT:
-            make_1d_stack_mipmap(convertFormat, border,
+            make_1d_stack_mipmap(datatype, comps, border,
                                  srcWidth, srcData,
                                  dstWidth, dstHeight, dstData);
             break;
          case GL_TEXTURE_2D_ARRAY_EXT:
-            make_2d_stack_mipmap(convertFormat, border,
+            make_2d_stack_mipmap(datatype, comps, border,
                                  srcWidth, srcHeight, srcData,
                                  dstWidth, dstHeight, dstDepth, dstData);
             break;