mesa: Convert format_pack/unpack off of GL types.

Reviewed-by: Rob Clark <[email protected]>
Reviewed-by: Kristian H. Kristensen <[email protected]>

1 files changed, 137 insertions, 137 deletions

diff --git a/src/mesa/main/format_unpack.py b/src/mesa/main/format_unpack.py
index d99cedb7907..54df8efb7ce 100644
--- a/src/mesa/main/format_unpack.py
+++ b/src/mesa/main/format_unpack.py
@@ -79,7 +79,7 @@ for f in formats:
    %endif
 
 static inline void
-unpack_float_${f.short_name()}(const void *void_src, GLfloat dst[4])
+unpack_float_${f.short_name()}(const void *void_src, float dst[4])
 {
    ${f.datatype()} *src = (${f.datatype()} *)void_src;
    %if f.layout == parser.PACKED:
@@ -134,34 +134,34 @@ unpack_float_${f.short_name()}(const void *void_src, GLfloat dst[4])
 %endfor
 
 static void
-unpack_float_r9g9b9e5_float(const void *src, GLfloat dst[4])
+unpack_float_r9g9b9e5_float(const void *src, float dst[4])
 {
-   rgb9e5_to_float3(*(const GLuint *)src, dst);
+   rgb9e5_to_float3(*(const uint32_t *)src, dst);
    dst[3] = 1.0f;
 }
 
 static void
-unpack_float_r11g11b10_float(const void *src, GLfloat dst[4])
+unpack_float_r11g11b10_float(const void *src, float dst[4])
 {
-   r11g11b10f_to_float3(*(const GLuint *)src, dst);
+   r11g11b10f_to_float3(*(const uint32_t *)src, dst);
    dst[3] = 1.0f;
 }
 
 static void
-unpack_float_ycbcr(const void *src, GLfloat dst[][4], GLuint n)
+unpack_float_ycbcr(const void *src, float dst[][4], uint32_t n)
 {
-   GLuint i;
+   uint32_t i;
    for (i = 0; i < n; i++) {
-      const GLushort *src0 = ((const GLushort *) src) + i * 2; /* even */
-      const GLushort *src1 = src0 + 1;         /* odd */
-      const GLubyte y0 = (*src0 >> 8) & 0xff;  /* luminance */
-      const GLubyte cb = *src0 & 0xff;         /* chroma U */
-      const GLubyte y1 = (*src1 >> 8) & 0xff;  /* luminance */
-      const GLubyte cr = *src1 & 0xff;         /* chroma V */
-      const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
-      GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
-      GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
-      GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
+      const uint16_t *src0 = ((const uint16_t *) src) + i * 2; /* even */
+      const uint16_t *src1 = src0 + 1;         /* odd */
+      const uint8_t y0 = (*src0 >> 8) & 0xff;  /* luminance */
+      const uint8_t cb = *src0 & 0xff;         /* chroma U */
+      const uint8_t y1 = (*src1 >> 8) & 0xff;  /* luminance */
+      const uint8_t cr = *src1 & 0xff;         /* chroma V */
+      const uint8_t y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
+      float r = 1.164F * (y - 16) + 1.596F * (cr - 128);
+      float g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
+      float b = 1.164F * (y - 16) + 2.018F * (cb - 128);
       r *= (1.0F / 255.0F);
       g *= (1.0F / 255.0F);
       b *= (1.0F / 255.0F);
@@ -173,20 +173,20 @@ unpack_float_ycbcr(const void *src, GLfloat dst[][4], GLuint n)
 }
 
 static void
-unpack_float_ycbcr_rev(const void *src, GLfloat dst[][4], GLuint n)
+unpack_float_ycbcr_rev(const void *src, float dst[][4], uint32_t n)
 {
-   GLuint i;
+   uint32_t i;
    for (i = 0; i < n; i++) {
-      const GLushort *src0 = ((const GLushort *) src) + i * 2; /* even */
-      const GLushort *src1 = src0 + 1;         /* odd */
-      const GLubyte y0 = *src0 & 0xff;         /* luminance */
-      const GLubyte cr = (*src0 >> 8) & 0xff;  /* chroma V */
-      const GLubyte y1 = *src1 & 0xff;         /* luminance */
-      const GLubyte cb = (*src1 >> 8) & 0xff;  /* chroma U */
-      const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
-      GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
-      GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
-      GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
+      const uint16_t *src0 = ((const uint16_t *) src) + i * 2; /* even */
+      const uint16_t *src1 = src0 + 1;         /* odd */
+      const uint8_t y0 = *src0 & 0xff;         /* luminance */
+      const uint8_t cr = (*src0 >> 8) & 0xff;  /* chroma V */
+      const uint8_t y1 = *src1 & 0xff;         /* luminance */
+      const uint8_t cb = (*src1 >> 8) & 0xff;  /* chroma U */
+      const uint8_t y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
+      float r = 1.164F * (y - 16) + 1.596F * (cr - 128);
+      float g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
+      float b = 1.164F * (y - 16) + 2.018F * (cb - 128);
       r *= (1.0F / 255.0F);
       g *= (1.0F / 255.0F);
       b *= (1.0F / 255.0F);
@@ -205,7 +205,7 @@ unpack_float_ycbcr_rev(const void *src, GLfloat dst[][4], GLuint n)
    %endif
 
 static inline void
-unpack_ubyte_${f.short_name()}(const void *void_src, GLubyte dst[4])
+unpack_ubyte_${f.short_name()}(const void *void_src, uint8_t dst[4])
 {
    ${f.datatype()} *src = (${f.datatype()} *)void_src;
    %if f.layout == parser.PACKED:
@@ -269,7 +269,7 @@ unpack_ubyte_${f.short_name()}(const void *void_src, GLubyte dst[4])
    %endif
 
 static inline void
-unpack_int_${f.short_name()}(const void *void_src, GLuint dst[4])
+unpack_int_${f.short_name()}(const void *void_src, uint32_t dst[4])
 {
    ${f.datatype()} *src = (${f.datatype()} *)void_src;
    %if f.layout == parser.PACKED:
@@ -305,11 +305,11 @@ unpack_int_${f.short_name()}(const void *void_src, GLuint dst[4])
 
 
 void
-_mesa_unpack_rgba_row(mesa_format format, GLuint n,
-                      const void *src, GLfloat dst[][4])
+_mesa_unpack_rgba_row(mesa_format format, uint32_t n,
+                      const void *src, float dst[][4])
 {
-   GLubyte *s = (GLubyte *)src;
-   GLuint i;
+   uint8_t *s = (uint8_t *)src;
+   uint32_t i;
 
    switch (format) {
 %for f in rgb_formats:
@@ -337,11 +337,11 @@ _mesa_unpack_rgba_row(mesa_format format, GLuint n,
 }
 
 void
-_mesa_unpack_ubyte_rgba_row(mesa_format format, GLuint n,
-                            const void *src, GLubyte dst[][4])
+_mesa_unpack_ubyte_rgba_row(mesa_format format, uint32_t n,
+                            const void *src, uint8_t dst[][4])
 {
-   GLubyte *s = (GLubyte *)src;
-   GLuint i;
+   uint8_t *s = (uint8_t *)src;
+   uint32_t i;
 
    switch (format) {
 %for f in rgb_formats:
@@ -359,10 +359,10 @@ _mesa_unpack_ubyte_rgba_row(mesa_format format, GLuint n,
    default:
       /* get float values, convert to ubyte */
       {
-         GLfloat *tmp = malloc(n * 4 * sizeof(GLfloat));
+         float *tmp = malloc(n * 4 * sizeof(float));
          if (tmp) {
-            GLuint i;
-            _mesa_unpack_rgba_row(format, n, src, (GLfloat (*)[4]) tmp);
+            uint32_t i;
+            _mesa_unpack_rgba_row(format, n, src, (float (*)[4]) tmp);
             for (i = 0; i < n; i++) {
                dst[i][0] = _mesa_float_to_unorm(tmp[i*4+0], 8);
                dst[i][1] = _mesa_float_to_unorm(tmp[i*4+1], 8);
@@ -377,11 +377,11 @@ _mesa_unpack_ubyte_rgba_row(mesa_format format, GLuint n,
 }
 
 void
-_mesa_unpack_uint_rgba_row(mesa_format format, GLuint n,
-                           const void *src, GLuint dst[][4])
+_mesa_unpack_uint_rgba_row(mesa_format format, uint32_t n,
+                           const void *src, uint32_t dst[][4])
 {
-   GLubyte *s = (GLubyte *)src;
-   GLuint i;
+   uint8_t *s = (uint8_t *)src;
+   uint32_t i;
 
    switch (format) {
 %for f in rgb_formats:
@@ -417,23 +417,23 @@ _mesa_unpack_uint_rgba_row(mesa_format format, GLuint n,
  */
 void
 _mesa_unpack_rgba_block(mesa_format format,
-                        const void *src, GLint srcRowStride,
-                        GLfloat dst[][4], GLint dstRowStride,
-                        GLuint x, GLuint y, GLuint width, GLuint height)
+                        const void *src, int32_t srcRowStride,
+                        float dst[][4], int32_t dstRowStride,
+                        uint32_t x, uint32_t y, uint32_t width, uint32_t height)
 {
-   const GLuint srcPixStride = _mesa_get_format_bytes(format);
-   const GLuint dstPixStride = 4 * sizeof(GLfloat);
-   const GLubyte *srcRow;
-   GLubyte *dstRow;
-   GLuint i;
+   const uint32_t srcPixStride = _mesa_get_format_bytes(format);
+   const uint32_t dstPixStride = 4 * sizeof(float);
+   const uint8_t *srcRow;
+   uint8_t *dstRow;
+   uint32_t i;
 
    /* XXX needs to be fixed for compressed formats */
 
-   srcRow = ((const GLubyte *) src) + srcRowStride * y + srcPixStride * x;
-   dstRow = ((GLubyte *) dst) + dstRowStride * y + dstPixStride * x;
+   srcRow = ((const uint8_t *) src) + srcRowStride * y + srcPixStride * x;
+   dstRow = ((uint8_t *) dst) + dstRowStride * y + dstPixStride * x;
 
    for (i = 0; i < height; i++) {
-      _mesa_unpack_rgba_row(format, width, srcRow, (GLfloat (*)[4]) dstRow);
+      _mesa_unpack_rgba_row(format, width, srcRow, (float (*)[4]) dstRow);
 
       dstRow += dstRowStride;
       srcRow += srcRowStride;
@@ -447,67 +447,67 @@ struct z32f_x24s8
    uint32_t x24s8;
 };
 
-typedef void (*unpack_float_z_func)(GLuint n, const void *src, GLfloat *dst);
+typedef void (*unpack_float_z_func)(uint32_t n, const void *src, float *dst);
 
 static void
-unpack_float_z_X8_UINT_Z24_UNORM(GLuint n, const void *src, GLfloat *dst)
+unpack_float_z_X8_UINT_Z24_UNORM(uint32_t n, const void *src, float *dst)
 {
    /* only return Z, not stencil data */
-   const GLuint *s = ((const GLuint *) src);
-   const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
-   GLuint i;
+   const uint32_t *s = ((const uint32_t *) src);
+   const double scale = 1.0 / (double) 0xffffff;
+   uint32_t i;
    for (i = 0; i < n; i++) {
-      dst[i] = (GLfloat) ((s[i] >> 8) * scale);
+      dst[i] = (float) ((s[i] >> 8) * scale);
       assert(dst[i] >= 0.0F);
       assert(dst[i] <= 1.0F);
    }
 }
 
 static void
-unpack_float_z_Z24_UNORM_X8_UINT(GLuint n, const void *src, GLfloat *dst)
+unpack_float_z_Z24_UNORM_X8_UINT(uint32_t n, const void *src, float *dst)
 {
    /* only return Z, not stencil data */
-   const GLuint *s = ((const GLuint *) src);
-   const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
-   GLuint i;
+   const uint32_t *s = ((const uint32_t *) src);
+   const double scale = 1.0 / (double) 0xffffff;
+   uint32_t i;
    for (i = 0; i < n; i++) {
-      dst[i] = (GLfloat) ((s[i] & 0x00ffffff) * scale);
+      dst[i] = (float) ((s[i] & 0x00ffffff) * scale);
       assert(dst[i] >= 0.0F);
       assert(dst[i] <= 1.0F);
    }
 }
 
 static void
-unpack_float_Z_UNORM16(GLuint n, const void *src, GLfloat *dst)
+unpack_float_Z_UNORM16(uint32_t n, const void *src, float *dst)
 {
-   const GLushort *s = ((const GLushort *) src);
-   GLuint i;
+   const uint16_t *s = ((const uint16_t *) src);
+   uint32_t i;
    for (i = 0; i < n; i++) {
       dst[i] = s[i] * (1.0F / 65535.0F);
    }
 }
 
 static void
-unpack_float_Z_UNORM32(GLuint n, const void *src, GLfloat *dst)
+unpack_float_Z_UNORM32(uint32_t n, const void *src, float *dst)
 {
-   const GLuint *s = ((const GLuint *) src);
-   GLuint i;
+   const uint32_t *s = ((const uint32_t *) src);
+   uint32_t i;
    for (i = 0; i < n; i++) {
       dst[i] = s[i] * (1.0F / 0xffffffff);
    }
 }
 
 static void
-unpack_float_Z_FLOAT32(GLuint n, const void *src, GLfloat *dst)
+unpack_float_Z_FLOAT32(uint32_t n, const void *src, float *dst)
 {
    memcpy(dst, src, n * sizeof(float));
 }
 
 static void
-unpack_float_z_Z32X24S8(GLuint n, const void *src, GLfloat *dst)
+unpack_float_z_Z32X24S8(uint32_t n, const void *src, float *dst)
 {
    const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
-   GLuint i;
+   uint32_t i;
    for (i = 0; i < n; i++) {
       dst[i] = s[i].z;
    }
@@ -520,8 +520,8 @@ unpack_float_z_Z32X24S8(GLuint n, const void *src, GLfloat *dst)
  * The returned values will always be in the range [0.0, 1.0].
  */
 void
-_mesa_unpack_float_z_row(mesa_format format, GLuint n,
-                         const void *src, GLfloat *dst)
+_mesa_unpack_float_z_row(mesa_format format, uint32_t n,
+                         const void *src, float *dst)
 {
    unpack_float_z_func unpack;
 
@@ -555,61 +555,61 @@ _mesa_unpack_float_z_row(mesa_format format, GLuint n,
 
 
 
-typedef void (*unpack_uint_z_func)(const void *src, GLuint *dst, GLuint n);
+typedef void (*unpack_uint_z_func)(const void *src, uint32_t *dst, uint32_t n);
 
 static void
-unpack_uint_z_X8_UINT_Z24_UNORM(const void *src, GLuint *dst, GLuint n)
+unpack_uint_z_X8_UINT_Z24_UNORM(const void *src, uint32_t *dst, uint32_t n)
 {
    /* only return Z, not stencil data */
-   const GLuint *s = ((const GLuint *) src);
-   GLuint i;
+   const uint32_t *s = ((const uint32_t *) src);
+   uint32_t i;
    for (i = 0; i < n; i++) {
       dst[i] = (s[i] & 0xffffff00) | (s[i] >> 24);
    }
 }
 
 static void
-unpack_uint_z_Z24_UNORM_X8_UINT(const void *src, GLuint *dst, GLuint n)
+unpack_uint_z_Z24_UNORM_X8_UINT(const void *src, uint32_t *dst, uint32_t n)
 {
    /* only return Z, not stencil data */
-   const GLuint *s = ((const GLuint *) src);
-   GLuint i;
+   const uint32_t *s = ((const uint32_t *) src);
+   uint32_t i;
    for (i = 0; i < n; i++) {
       dst[i] = (s[i] << 8) | ((s[i] >> 16) & 0xff);
    }
 }
 
 static void
-unpack_uint_Z_UNORM16(const void *src, GLuint *dst, GLuint n)
+unpack_uint_Z_UNORM16(const void *src, uint32_t *dst, uint32_t n)
 {
-   const GLushort *s = ((const GLushort *)src);
-   GLuint i;
+   const uint16_t *s = ((const uint16_t *)src);
+   uint32_t i;
    for (i = 0; i < n; i++) {
       dst[i] = (s[i] << 16) | s[i];
    }
 }
 
 static void
-unpack_uint_Z_UNORM32(const void *src, GLuint *dst, GLuint n)
+unpack_uint_Z_UNORM32(const void *src, uint32_t *dst, uint32_t n)
 {
-   memcpy(dst, src, n * sizeof(GLuint));
+   memcpy(dst, src, n * sizeof(uint32_t));
 }
 
 static void
-unpack_uint_Z_FLOAT32(const void *src, GLuint *dst, GLuint n)
+unpack_uint_Z_FLOAT32(const void *src, uint32_t *dst, uint32_t n)
 {
    const float *s = (const float *)src;
-   GLuint i;
+   uint32_t i;
    for (i = 0; i < n; i++) {
       dst[i] = FLOAT_TO_UINT(CLAMP(s[i], 0.0F, 1.0F));
    }
 }
 
 static void
-unpack_uint_Z_FLOAT32_X24S8(const void *src, GLuint *dst, GLuint n)
+unpack_uint_Z_FLOAT32_X24S8(const void *src, uint32_t *dst, uint32_t n)
 {
    const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
-   GLuint i;
+   uint32_t i;
 
    for (i = 0; i < n; i++) {
       dst[i] = FLOAT_TO_UINT(CLAMP(s[i].z, 0.0F, 1.0F));
@@ -622,11 +622,11 @@ unpack_uint_Z_FLOAT32_X24S8(const void *src, GLuint *dst, GLuint n)
  * The returned values will always be in the range [0, 0xffffffff].
  */
 void
-_mesa_unpack_uint_z_row(mesa_format format, GLuint n,
-                        const void *src, GLuint *dst)
+_mesa_unpack_uint_z_row(mesa_format format, uint32_t n,
+                        const void *src, uint32_t *dst)
 {
    unpack_uint_z_func unpack;
-   const GLubyte *srcPtr = (GLubyte *) src;
+   const uint8_t *srcPtr = (uint8_t *) src;
 
    switch (format) {
    case MESA_FORMAT_S8_UINT_Z24_UNORM:
@@ -658,35 +658,35 @@ _mesa_unpack_uint_z_row(mesa_format format, GLuint n,
 
 
 static void
-unpack_ubyte_s_S_UINT8(const void *src, GLubyte *dst, GLuint n)
+unpack_ubyte_s_S_UINT8(const void *src, uint8_t *dst, uint32_t n)
 {
    memcpy(dst, src, n);
 }
 
 static void
-unpack_ubyte_s_S8_UINT_Z24_UNORM(const void *src, GLubyte *dst, GLuint n)
+unpack_ubyte_s_S8_UINT_Z24_UNORM(const void *src, uint8_t *dst, uint32_t n)
 {
-   GLuint i;
-   const GLuint *src32 = src;
+   uint32_t i;
+   const uint32_t *src32 = src;
 
    for (i = 0; i < n; i++)
       dst[i] = src32[i] & 0xff;
 }
 
 static void
-unpack_ubyte_s_Z24_UNORM_S8_UINT(const void *src, GLubyte *dst, GLuint n)
+unpack_ubyte_s_Z24_UNORM_S8_UINT(const void *src, uint8_t *dst, uint32_t n)
 {
-   GLuint i;
-   const GLuint *src32 = src;
+   uint32_t i;
+   const uint32_t *src32 = src;
 
    for (i = 0; i < n; i++)
       dst[i] = src32[i] >> 24;
 }
 
 static void
-unpack_ubyte_s_Z32_FLOAT_S8X24_UINT(const void *src, GLubyte *dst, GLuint n)
+unpack_ubyte_s_Z32_FLOAT_S8X24_UINT(const void *src, uint8_t *dst, uint32_t n)
 {
-   GLuint i;
+   uint32_t i;
    const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
 
    for (i = 0; i < n; i++)
@@ -694,8 +694,8 @@ unpack_ubyte_s_Z32_FLOAT_S8X24_UINT(const void *src, GLubyte *dst, GLuint n)
 }
 
 void
-_mesa_unpack_ubyte_stencil_row(mesa_format format, GLuint n,
-			       const void *src, GLubyte *dst)
+_mesa_unpack_ubyte_stencil_row(mesa_format format, uint32_t n,
+			       const void *src, uint8_t *dst)
 {
    switch (format) {
    case MESA_FORMAT_S_UINT8:
@@ -716,33 +716,33 @@ _mesa_unpack_ubyte_stencil_row(mesa_format format, GLuint n,
 }
 
 static void
-unpack_uint_24_8_depth_stencil_Z24_UNORM_S8_UINT(const GLuint *src, GLuint *dst, GLuint n)
+unpack_uint_24_8_depth_stencil_Z24_UNORM_S8_UINT(const uint32_t *src, uint32_t *dst, uint32_t n)
 {
-   GLuint i;
+   uint32_t i;
 
    for (i = 0; i < n; i++) {
-      GLuint val = src[i];
+      uint32_t val = src[i];
       dst[i] = val >> 24 | val << 8;
    }
 }
 
 static void
-unpack_uint_24_8_depth_stencil_Z32_S8X24(const GLuint *src,
-                                         GLuint *dst, GLuint n)
+unpack_uint_24_8_depth_stencil_Z32_S8X24(const uint32_t *src,
+                                         uint32_t *dst, uint32_t n)
 {
-   GLuint i;
+   uint32_t i;
 
    for (i = 0; i < n; i++) {
       /* 8 bytes per pixel (float + uint32) */
-      GLfloat zf = ((GLfloat *) src)[i * 2 + 0];
-      GLuint z24 = (GLuint) (zf * (GLfloat) 0xffffff);
-      GLuint s = src[i * 2 + 1] & 0xff;
+      float zf = ((float *) src)[i * 2 + 0];
+      uint32_t z24 = (uint32_t) (zf * (float) 0xffffff);
+      uint32_t s = src[i * 2 + 1] & 0xff;
       dst[i] = (z24 << 8) | s;
    }
 }
 
 static void
-unpack_uint_24_8_depth_stencil_S8_UINT_Z24_UNORM(const GLuint *src, GLuint *dst, GLuint n)
+unpack_uint_24_8_depth_stencil_S8_UINT_Z24_UNORM(const uint32_t *src, uint32_t *dst, uint32_t n)
 {
    memcpy(dst, src, n * 4);
 }
@@ -752,8 +752,8 @@ unpack_uint_24_8_depth_stencil_S8_UINT_Z24_UNORM(const GLuint *src, GLuint *dst,
  * \param format  the source data format
  */
 void
-_mesa_unpack_uint_24_8_depth_stencil_row(mesa_format format, GLuint n,
-					 const void *src, GLuint *dst)
+_mesa_unpack_uint_24_8_depth_stencil_row(mesa_format format, uint32_t n,
+					 const void *src, uint32_t *dst)
 {
    switch (format) {
    case MESA_FORMAT_S8_UINT_Z24_UNORM:
@@ -771,15 +771,15 @@ _mesa_unpack_uint_24_8_depth_stencil_row(mesa_format format, GLuint n,
 }
 
 static void
-unpack_float_32_uint_24_8_Z24_UNORM_S8_UINT(const GLuint *src,
-                                            GLuint *dst, GLuint n)
+unpack_float_32_uint_24_8_Z24_UNORM_S8_UINT(const uint32_t *src,
+                                            uint32_t *dst, uint32_t n)
 {
-   GLuint i;
+   uint32_t i;
    struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
-   const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
+   const double scale = 1.0 / (double) 0xffffff;
 
    for (i = 0; i < n; i++) {
-      const GLuint z24 = src[i] & 0xffffff;
+      const uint32_t z24 = src[i] & 0xffffff;
       d[i].z = z24 * scale;
       d[i].x24s8 = src[i] >> 24;
       assert(d[i].z >= 0.0f);
@@ -788,22 +788,22 @@ unpack_float_32_uint_24_8_Z24_UNORM_S8_UINT(const GLuint *src,
 }
 
 static void
-unpack_float_32_uint_24_8_Z32_FLOAT_S8X24_UINT(const GLuint *src,
-                                               GLuint *dst, GLuint n)
+unpack_float_32_uint_24_8_Z32_FLOAT_S8X24_UINT(const uint32_t *src,
+                                               uint32_t *dst, uint32_t n)
 {
    memcpy(dst, src, n * sizeof(struct z32f_x24s8));
 }
 
 static void
-unpack_float_32_uint_24_8_S8_UINT_Z24_UNORM(const GLuint *src,
-                                            GLuint *dst, GLuint n)
+unpack_float_32_uint_24_8_S8_UINT_Z24_UNORM(const uint32_t *src,
+                                            uint32_t *dst, uint32_t n)
 {
-   GLuint i;
+   uint32_t i;
    struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
-   const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
+   const double scale = 1.0 / (double) 0xffffff;
 
    for (i = 0; i < n; i++) {
-      const GLuint z24 = src[i] >> 8;
+      const uint32_t z24 = src[i] >> 8;
       d[i].z = z24 * scale;
       d[i].x24s8 = src[i] & 0xff;
       assert(d[i].z >= 0.0f);
@@ -826,8 +826,8 @@ unpack_float_32_uint_24_8_S8_UINT_Z24_UNORM(const GLuint *src,
  *          lower 4 bytes                  higher 4 bytes
  */
 void
-_mesa_unpack_float_32_uint_24_8_depth_stencil_row(mesa_format format, GLuint n,
-			                          const void *src, GLuint *dst)
+_mesa_unpack_float_32_uint_24_8_depth_stencil_row(mesa_format format, uint32_t n,
+			                          const void *src, uint32_t *dst)
 {
    switch (format) {
    case MESA_FORMAT_S8_UINT_Z24_UNORM:
@@ -850,9 +850,9 @@ _mesa_unpack_float_32_uint_24_8_depth_stencil_row(mesa_format format, GLuint n,
  * \param type the destination data type
  */
 void
-_mesa_unpack_depth_stencil_row(mesa_format format, GLuint n,
+_mesa_unpack_depth_stencil_row(mesa_format format, uint32_t n,
 	                       const void *src, GLenum type,
-                               GLuint *dst)
+                               uint32_t *dst)
 {
    assert(type == GL_UNSIGNED_INT_24_8 ||
           type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);