mesa update 11 july 2011

3 files changed, 1742 insertions, 1610 deletions

diff --git a/mesalib/src/gallium/auxiliary/util/u_pack_color.h b/mesalib/src/gallium/auxiliary/util/u_pack_color.h
index c51cc7bcb..9391f1b80 100644
--- a/mesalib/src/gallium/auxiliary/util/u_pack_color.h
+++ b/mesalib/src/gallium/auxiliary/util/u_pack_color.h
@@ -1,584 +1,648 @@
-/**************************************************************************

- *

- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.

- * All Rights Reserved.

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the

- * "Software"), to deal in the Software without restriction, including

- * without limitation the rights to use, copy, modify, merge, publish,

- * distribute, sub license, and/or sell copies of the Software, and to

- * permit persons to whom the Software is furnished to do so, subject to

- * the following conditions:

- *

- * The above copyright notice and this permission notice (including the

- * next paragraph) shall be included in all copies or substantial portions

- * of the Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.

- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR

- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- *

- **************************************************************************/

-

-/**

- * @file

- * Functions to produce packed colors/Z from floats.

- */

-

-

-#ifndef U_PACK_COLOR_H

-#define U_PACK_COLOR_H

-

-

-#include "pipe/p_compiler.h"

-#include "pipe/p_format.h"

-#include "util/u_debug.h"

-#include "util/u_format.h"

-#include "util/u_math.h"

-

-

-/**

- * Helper union for packing pixel values.

- * Will often contain values in formats which are too complex to be described

- * in simple terms, hence might just effectively contain a number of bytes.

- * Must be big enough to hold data for all formats (currently 256 bits).

- */

-union util_color {

-   ubyte ub;

-   ushort us;

-   uint ui;

-   float f[4];

-   double d[4];

-};

-

-/**

- * Pack ubyte R,G,B,A into dest pixel.

- */

-static INLINE void

-util_pack_color_ub(ubyte r, ubyte g, ubyte b, ubyte a,

-                   enum pipe_format format, union util_color *uc)

-{

-   switch (format) {

-   case PIPE_FORMAT_A8B8G8R8_UNORM:

-      {

-         uc->ui = (r << 24) | (g << 16) | (b << 8) | a;

-      }

-      return;

-   case PIPE_FORMAT_X8B8G8R8_UNORM:

-      {

-         uc->ui = (r << 24) | (g << 16) | (b << 8) | 0xff;

-      }

-      return;

-   case PIPE_FORMAT_B8G8R8A8_UNORM:

-      {

-         uc->ui = (a << 24) | (r << 16) | (g << 8) | b;

-      }

-      return;

-   case PIPE_FORMAT_B8G8R8X8_UNORM:

-      {

-         uc->ui = (0xff << 24) | (r << 16) | (g << 8) | b;

-      }

-      return;

-   case PIPE_FORMAT_A8R8G8B8_UNORM:

-      {

-         uc->ui = (b << 24) | (g << 16) | (r << 8) | a;

-      }

-      return;

-   case PIPE_FORMAT_X8R8G8B8_UNORM:

-      {

-         uc->ui = (b << 24) | (g << 16) | (r << 8) | 0xff;

-      }

-      return;

-   case PIPE_FORMAT_B5G6R5_UNORM:

-      {

-         uc->us = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | (b >> 3);

-      }

-      return;

-   case PIPE_FORMAT_B5G5R5X1_UNORM:

-      {

-         uc->us = ((0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);

-      }

-      return;

-   case PIPE_FORMAT_B5G5R5A1_UNORM:

-      {

-         uc->us = ((a & 0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);

-      }

-      return;

-   case PIPE_FORMAT_B4G4R4A4_UNORM:

-      {

-         uc->us = ((a & 0xf0) << 8) | ((r & 0xf0) << 4) | ((g & 0xf0) << 0) | (b >> 4);

-      }

-      return;

-   case PIPE_FORMAT_A8_UNORM:

-      {

-         uc->ub = a;

-      }

-      return;

-   case PIPE_FORMAT_L8_UNORM:

-   case PIPE_FORMAT_I8_UNORM:

-      {

-         uc->ub = a;

-      }

-      return;

-   case PIPE_FORMAT_R32G32B32A32_FLOAT:

-      {

-         uc->f[0] = (float)r / 255.0f;

-         uc->f[1] = (float)g / 255.0f;

-         uc->f[2] = (float)b / 255.0f;

-         uc->f[3] = (float)a / 255.0f;

-      }

-      return;

-   case PIPE_FORMAT_R32G32B32_FLOAT:

-      {

-         uc->f[0] = (float)r / 255.0f;

-         uc->f[1] = (float)g / 255.0f;

-         uc->f[2] = (float)b / 255.0f;

-      }

-      return;

-

-   /* Handle other cases with a generic function.

-    */

-   default:

-      {

-         ubyte src[4];

-

-         src[0] = r;

-         src[1] = g;

-         src[2] = b;

-         src[3] = a;

-         util_format_write_4ub(format, src, 0, uc, 0, 0, 0, 1, 1);

-      }

-   }

-}

- 

-

-/**

- * Unpack RGBA from a packed pixel, returning values as ubytes in [0,255].

- */

-static INLINE void

-util_unpack_color_ub(enum pipe_format format, union util_color *uc,

-                     ubyte *r, ubyte *g, ubyte *b, ubyte *a)

-{

-   switch (format) {

-   case PIPE_FORMAT_A8B8G8R8_UNORM:

-      {

-         uint p = uc->ui;

-         *r = (ubyte) ((p >> 24) & 0xff);

-         *g = (ubyte) ((p >> 16) & 0xff);

-         *b = (ubyte) ((p >>  8) & 0xff);

-         *a = (ubyte) ((p >>  0) & 0xff);

-      }

-      return;

-   case PIPE_FORMAT_X8B8G8R8_UNORM:

-      {

-         uint p = uc->ui;

-         *r = (ubyte) ((p >> 24) & 0xff);

-         *g = (ubyte) ((p >> 16) & 0xff);

-         *b = (ubyte) ((p >>  8) & 0xff);

-         *a = (ubyte) 0xff;

-      }

-      return;

-   case PIPE_FORMAT_B8G8R8A8_UNORM:

-      {

-         uint p = uc->ui;

-         *r = (ubyte) ((p >> 16) & 0xff);

-         *g = (ubyte) ((p >>  8) & 0xff);

-         *b = (ubyte) ((p >>  0) & 0xff);

-         *a = (ubyte) ((p >> 24) & 0xff);

-      }

-      return;

-   case PIPE_FORMAT_B8G8R8X8_UNORM:

-      {

-         uint p = uc->ui;

-         *r = (ubyte) ((p >> 16) & 0xff);

-         *g = (ubyte) ((p >>  8) & 0xff);

-         *b = (ubyte) ((p >>  0) & 0xff);

-         *a = (ubyte) 0xff;

-      }

-      return;

-   case PIPE_FORMAT_A8R8G8B8_UNORM:

-      {

-         uint p = uc->ui;

-         *r = (ubyte) ((p >>  8) & 0xff);

-         *g = (ubyte) ((p >> 16) & 0xff);

-         *b = (ubyte) ((p >> 24) & 0xff);

-         *a = (ubyte) ((p >>  0) & 0xff);

-      }

-      return;

-   case PIPE_FORMAT_X8R8G8B8_UNORM:

-      {

-         uint p = uc->ui;

-         *r = (ubyte) ((p >>  8) & 0xff);

-         *g = (ubyte) ((p >> 16) & 0xff);

-         *b = (ubyte) ((p >> 24) & 0xff);

-         *a = (ubyte) 0xff;

-      }

-      return;

-   case PIPE_FORMAT_B5G6R5_UNORM:

-      {

-         ushort p = uc->us;

-         *r = (ubyte) (((p >> 8) & 0xf8) | ((p >> 13) & 0x7));

-         *g = (ubyte) (((p >> 3) & 0xfc) | ((p >>  9) & 0x3));

-         *b = (ubyte) (((p << 3) & 0xf8) | ((p >>  2) & 0x7));

-         *a = (ubyte) 0xff;

-      }

-      return;

-   case PIPE_FORMAT_B5G5R5X1_UNORM:

-      {

-         ushort p = uc->us;

-         *r = (ubyte) (((p >>  7) & 0xf8) | ((p >> 12) & 0x7));

-         *g = (ubyte) (((p >>  2) & 0xf8) | ((p >>  7) & 0x7));

-         *b = (ubyte) (((p <<  3) & 0xf8) | ((p >>  2) & 0x7));

-         *a = (ubyte) 0xff;

-      }

-      return;

-   case PIPE_FORMAT_B5G5R5A1_UNORM:

-      {

-         ushort p = uc->us;

-         *r = (ubyte) (((p >>  7) & 0xf8) | ((p >> 12) & 0x7));

-         *g = (ubyte) (((p >>  2) & 0xf8) | ((p >>  7) & 0x7));

-         *b = (ubyte) (((p <<  3) & 0xf8) | ((p >>  2) & 0x7));

-         *a = (ubyte) (0xff * (p >> 15));

-      }

-      return;

-   case PIPE_FORMAT_B4G4R4A4_UNORM:

-      {

-         ushort p = uc->us;

-         *r = (ubyte) (((p >> 4) & 0xf0) | ((p >>  8) & 0xf));

-         *g = (ubyte) (((p >> 0) & 0xf0) | ((p >>  4) & 0xf));

-         *b = (ubyte) (((p << 4) & 0xf0) | ((p >>  0) & 0xf));

-         *a = (ubyte) (((p >> 8) & 0xf0) | ((p >> 12) & 0xf));

-      }

-      return;

-   case PIPE_FORMAT_A8_UNORM:

-      {

-         ubyte p = uc->ub;

-         *r = *g = *b = (ubyte) 0xff;

-         *a = p;

-      }

-      return;

-   case PIPE_FORMAT_L8_UNORM:

-      {

-         ubyte p = uc->ub;

-         *r = *g = *b = p;

-         *a = (ubyte) 0xff;

-      }

-      return;

-   case PIPE_FORMAT_I8_UNORM:

-      {

-         ubyte p = uc->ub;

-         *r = *g = *b = *a = p;

-      }

-      return;

-   case PIPE_FORMAT_R32G32B32A32_FLOAT:

-      {

-         const float *p = &uc->f[0];

-         *r = float_to_ubyte(p[0]);

-         *g = float_to_ubyte(p[1]);

-         *b = float_to_ubyte(p[2]);

-         *a = float_to_ubyte(p[3]);

-      }

-      return;

-   case PIPE_FORMAT_R32G32B32_FLOAT:

-      {

-         const float *p = &uc->f[0];

-         *r = float_to_ubyte(p[0]);

-         *g = float_to_ubyte(p[1]);

-         *b = float_to_ubyte(p[2]);

-         *a = (ubyte) 0xff;

-      }

-      return;

-

-   case PIPE_FORMAT_R32G32_FLOAT:

-      {

-         const float *p = &uc->f[0];

-         *r = float_to_ubyte(p[0]);

-         *g = float_to_ubyte(p[1]);

-         *b = *a = (ubyte) 0xff;

-      }

-      return;

-

-   case PIPE_FORMAT_R32_FLOAT:

-      {

-         const float *p = &uc->f[0];

-         *r = float_to_ubyte(p[0]);

-         *g = *b = *a = (ubyte) 0xff;

-      }

-      return;

-

-   /* Handle other cases with a generic function.

-    */

-   default:

-      {

-         ubyte dst[4];

-

-         util_format_read_4ub(format, dst, 0, uc, 0, 0, 0, 1, 1);

-         *r = dst[0];

-         *g = dst[1];

-         *b = dst[2];

-         *a = dst[3];

-      }

-   }

-}

-

-

-/**

- * Note rgba outside [0,1] will be clamped for int pixel formats.

- */

-static INLINE void

-util_pack_color(const float rgba[4], enum pipe_format format, union util_color *uc)

-{

-   ubyte r = 0;

-   ubyte g = 0;

-   ubyte b = 0;

-   ubyte a = 0;

-

-   if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0) <= 8) {

-      /* format uses 8-bit components or less */

-      r = float_to_ubyte(rgba[0]);

-      g = float_to_ubyte(rgba[1]);

-      b = float_to_ubyte(rgba[2]);

-      a = float_to_ubyte(rgba[3]);

-   }

-

-   switch (format) {

-   case PIPE_FORMAT_A8B8G8R8_UNORM:

-      {

-         uc->ui = (r << 24) | (g << 16) | (b << 8) | a;

-      }

-      return;

-   case PIPE_FORMAT_X8B8G8R8_UNORM:

-      {

-         uc->ui = (r << 24) | (g << 16) | (b << 8) | 0xff;

-      }

-      return;

-   case PIPE_FORMAT_B8G8R8A8_UNORM:

-      {

-         uc->ui = (a << 24) | (r << 16) | (g << 8) | b;

-      }

-      return;

-   case PIPE_FORMAT_B8G8R8X8_UNORM:

-      {

-         uc->ui = (0xff << 24) | (r << 16) | (g << 8) | b;

-      }

-      return;

-   case PIPE_FORMAT_A8R8G8B8_UNORM:

-      {

-         uc->ui = (b << 24) | (g << 16) | (r << 8) | a;

-      }

-      return;

-   case PIPE_FORMAT_X8R8G8B8_UNORM:

-      {

-         uc->ui = (b << 24) | (g << 16) | (r << 8) | 0xff;

-      }

-      return;

-   case PIPE_FORMAT_B5G6R5_UNORM:

-      {

-         uc->us = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | (b >> 3);

-      }

-      return;

-   case PIPE_FORMAT_B5G5R5X1_UNORM:

-      {

-         uc->us = ((0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);

-      }

-      return;

-   case PIPE_FORMAT_B5G5R5A1_UNORM:

-      {

-         uc->us = ((a & 0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);

-      }

-      return;

-   case PIPE_FORMAT_B4G4R4A4_UNORM:

-      {

-         uc->us = ((a & 0xf0) << 8) | ((r & 0xf0) << 4) | ((g & 0xf0) << 0) | (b >> 4);

-      }

-      return;

-   case PIPE_FORMAT_A8_UNORM:

-      {

-         uc->ub = a;

-      }

-      return;

-   case PIPE_FORMAT_L8_UNORM:

-   case PIPE_FORMAT_I8_UNORM:

-      {

-         uc->ub = r;

-      }

-      return;

-   case PIPE_FORMAT_R32G32B32A32_FLOAT:

-      {

-         uc->f[0] = rgba[0];

-         uc->f[1] = rgba[1];

-         uc->f[2] = rgba[2];

-         uc->f[3] = rgba[3];

-      }

-      return;

-   case PIPE_FORMAT_R32G32B32_FLOAT:

-      {

-         uc->f[0] = rgba[0];

-         uc->f[1] = rgba[1];

-         uc->f[2] = rgba[2];

-      }

-      return;

-

-   /* Handle other cases with a generic function.

-    */

-   default:

-      util_format_write_4f(format, rgba, 0, uc, 0, 0, 0, 1, 1);

-   }

-}

- 

-/* Integer versions of util_pack_z and util_pack_z_stencil - useful for

- * constructing clear masks.

- */

-static INLINE uint32_t

-util_pack_mask_z(enum pipe_format format, uint32_t z)

-{

-   switch (format) {

-   case PIPE_FORMAT_Z16_UNORM:

-      return z & 0xffff;

-   case PIPE_FORMAT_Z32_UNORM:

-   case PIPE_FORMAT_Z32_FLOAT:

-      return z;

-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

-   case PIPE_FORMAT_Z24X8_UNORM:

-      return z & 0xffffff;

-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

-   case PIPE_FORMAT_X8Z24_UNORM:

-      return (z & 0xffffff) << 8;

-   case PIPE_FORMAT_S8_USCALED:

-      return 0;

-   default:

-      debug_print_format("gallium: unhandled format in util_pack_mask_z()", format);

-      assert(0);

-      return 0;

-   }

-}

-

-static INLINE uint32_t

-util_pack_mask_z_stencil(enum pipe_format format, uint32_t z, uint8_t s)

-{

-   uint32_t packed = util_pack_mask_z(format, z);

-

-   switch (format) {

-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

-      packed |= (uint32_t)s << 24;

-      break;

-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

-      packed |= s;

-      break;

-   case PIPE_FORMAT_S8_USCALED:

-      packed |= s;

-      break;

-   default:

-      break;

-   }

-

-   return packed;

-}

-

-

-

-/**

- * Note: it's assumed that z is in [0,1]

- */

-static INLINE uint32_t

-util_pack_z(enum pipe_format format, double z)

-{

-   union fi fui;

-

-   if (z == 0.0)

-      return 0;

-

-   switch (format) {

-   case PIPE_FORMAT_Z16_UNORM:

-      if (z == 1.0)

-         return 0xffff;

-      return (uint32_t) (z * 0xffff);

-   case PIPE_FORMAT_Z32_UNORM:

-      /* special-case to avoid overflow */

-      if (z == 1.0)

-         return 0xffffffff;

-      return (uint32_t) (z * 0xffffffff);

-   case PIPE_FORMAT_Z32_FLOAT:

-      fui.f = (float)z;

-      return fui.ui;

-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

-   case PIPE_FORMAT_Z24X8_UNORM:

-      if (z == 1.0)

-         return 0xffffff;

-      return (uint32_t) (z * 0xffffff);

-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

-   case PIPE_FORMAT_X8Z24_UNORM:

-      if (z == 1.0)

-         return 0xffffff00;

-      return ((uint32_t) (z * 0xffffff)) << 8;

-   case PIPE_FORMAT_S8_USCALED:

-      /* this case can get it via util_pack_z_stencil() */

-      return 0;

-   default:

-      debug_print_format("gallium: unhandled format in util_pack_z()", format);

-      assert(0);

-      return 0;

-   }

-}

- 

-

-/**

- * Pack Z and/or stencil values into a 32-bit value described by format.

- * Note: it's assumed that z is in [0,1] and s in [0,255]

- */

-static INLINE uint32_t

-util_pack_z_stencil(enum pipe_format format, double z, uint8_t s)

-{

-   uint32_t packed = util_pack_z(format, z);

-

-   switch (format) {

-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

-      packed |= (uint32_t)s << 24;

-      break;

-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

-      packed |= s;

-      break;

-   case PIPE_FORMAT_S8_USCALED:

-      packed |= s;

-      break;

-   default:

-      break;

-   }

-

-   return packed;

-}

-

-

-/**

- * Pack 4 ubytes into a 4-byte word

- */

-static INLINE unsigned

-pack_ub4(ubyte b0, ubyte b1, ubyte b2, ubyte b3)

-{

-   return ((((unsigned int)b0) << 0) |

-	   (((unsigned int)b1) << 8) |

-	   (((unsigned int)b2) << 16) |

-	   (((unsigned int)b3) << 24));

-}

-

-

-/**

- * Pack/convert 4 floats into one 4-byte word.

- */

-static INLINE unsigned

-pack_ui32_float4(float a, float b, float c, float d)

-{

-   return pack_ub4( float_to_ubyte(a),

-		    float_to_ubyte(b),

-		    float_to_ubyte(c),

-		    float_to_ubyte(d) );

-}

-

-

-

-#endif /* U_PACK_COLOR_H */

+/**************************************************************************
+ *
+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+/**
+ * @file
+ * Functions to produce packed colors/Z from floats.
+ */
+
+
+#ifndef U_PACK_COLOR_H
+#define U_PACK_COLOR_H
+
+
+#include "pipe/p_compiler.h"
+#include "pipe/p_format.h"
+#include "util/u_debug.h"
+#include "util/u_format.h"
+#include "util/u_math.h"
+
+
+/**
+ * Helper union for packing pixel values.
+ * Will often contain values in formats which are too complex to be described
+ * in simple terms, hence might just effectively contain a number of bytes.
+ * Must be big enough to hold data for all formats (currently 256 bits).
+ */
+union util_color {
+   ubyte ub;
+   ushort us;
+   uint ui;
+   float f[4];
+   double d[4];
+};
+
+/**
+ * Pack ubyte R,G,B,A into dest pixel.
+ */
+static INLINE void
+util_pack_color_ub(ubyte r, ubyte g, ubyte b, ubyte a,
+                   enum pipe_format format, union util_color *uc)
+{
+   switch (format) {
+   case PIPE_FORMAT_A8B8G8R8_UNORM:
+      {
+         uc->ui = (r << 24) | (g << 16) | (b << 8) | a;
+      }
+      return;
+   case PIPE_FORMAT_X8B8G8R8_UNORM:
+      {
+         uc->ui = (r << 24) | (g << 16) | (b << 8) | 0xff;
+      }
+      return;
+   case PIPE_FORMAT_B8G8R8A8_UNORM:
+      {
+         uc->ui = (a << 24) | (r << 16) | (g << 8) | b;
+      }
+      return;
+   case PIPE_FORMAT_B8G8R8X8_UNORM:
+      {
+         uc->ui = (0xff << 24) | (r << 16) | (g << 8) | b;
+      }
+      return;
+   case PIPE_FORMAT_A8R8G8B8_UNORM:
+      {
+         uc->ui = (b << 24) | (g << 16) | (r << 8) | a;
+      }
+      return;
+   case PIPE_FORMAT_X8R8G8B8_UNORM:
+      {
+         uc->ui = (b << 24) | (g << 16) | (r << 8) | 0xff;
+      }
+      return;
+   case PIPE_FORMAT_B5G6R5_UNORM:
+      {
+         uc->us = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | (b >> 3);
+      }
+      return;
+   case PIPE_FORMAT_B5G5R5X1_UNORM:
+      {
+         uc->us = ((0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);
+      }
+      return;
+   case PIPE_FORMAT_B5G5R5A1_UNORM:
+      {
+         uc->us = ((a & 0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);
+      }
+      return;
+   case PIPE_FORMAT_B4G4R4A4_UNORM:
+      {
+         uc->us = ((a & 0xf0) << 8) | ((r & 0xf0) << 4) | ((g & 0xf0) << 0) | (b >> 4);
+      }
+      return;
+   case PIPE_FORMAT_A8_UNORM:
+      {
+         uc->ub = a;
+      }
+      return;
+   case PIPE_FORMAT_L8_UNORM:
+   case PIPE_FORMAT_I8_UNORM:
+      {
+         uc->ub = a;
+      }
+      return;
+   case PIPE_FORMAT_R32G32B32A32_FLOAT:
+      {
+         uc->f[0] = (float)r / 255.0f;
+         uc->f[1] = (float)g / 255.0f;
+         uc->f[2] = (float)b / 255.0f;
+         uc->f[3] = (float)a / 255.0f;
+      }
+      return;
+   case PIPE_FORMAT_R32G32B32_FLOAT:
+      {
+         uc->f[0] = (float)r / 255.0f;
+         uc->f[1] = (float)g / 255.0f;
+         uc->f[2] = (float)b / 255.0f;
+      }
+      return;
+
+   /* Handle other cases with a generic function.
+    */
+   default:
+      {
+         ubyte src[4];
+
+         src[0] = r;
+         src[1] = g;
+         src[2] = b;
+         src[3] = a;
+         util_format_write_4ub(format, src, 0, uc, 0, 0, 0, 1, 1);
+      }
+   }
+}
+ 
+
+/**
+ * Unpack RGBA from a packed pixel, returning values as ubytes in [0,255].
+ */
+static INLINE void
+util_unpack_color_ub(enum pipe_format format, union util_color *uc,
+                     ubyte *r, ubyte *g, ubyte *b, ubyte *a)
+{
+   switch (format) {
+   case PIPE_FORMAT_A8B8G8R8_UNORM:
+      {
+         uint p = uc->ui;
+         *r = (ubyte) ((p >> 24) & 0xff);
+         *g = (ubyte) ((p >> 16) & 0xff);
+         *b = (ubyte) ((p >>  8) & 0xff);
+         *a = (ubyte) ((p >>  0) & 0xff);
+      }
+      return;
+   case PIPE_FORMAT_X8B8G8R8_UNORM:
+      {
+         uint p = uc->ui;
+         *r = (ubyte) ((p >> 24) & 0xff);
+         *g = (ubyte) ((p >> 16) & 0xff);
+         *b = (ubyte) ((p >>  8) & 0xff);
+         *a = (ubyte) 0xff;
+      }
+      return;
+   case PIPE_FORMAT_B8G8R8A8_UNORM:
+      {
+         uint p = uc->ui;
+         *r = (ubyte) ((p >> 16) & 0xff);
+         *g = (ubyte) ((p >>  8) & 0xff);
+         *b = (ubyte) ((p >>  0) & 0xff);
+         *a = (ubyte) ((p >> 24) & 0xff);
+      }
+      return;
+   case PIPE_FORMAT_B8G8R8X8_UNORM:
+      {
+         uint p = uc->ui;
+         *r = (ubyte) ((p >> 16) & 0xff);
+         *g = (ubyte) ((p >>  8) & 0xff);
+         *b = (ubyte) ((p >>  0) & 0xff);
+         *a = (ubyte) 0xff;
+      }
+      return;
+   case PIPE_FORMAT_A8R8G8B8_UNORM:
+      {
+         uint p = uc->ui;
+         *r = (ubyte) ((p >>  8) & 0xff);
+         *g = (ubyte) ((p >> 16) & 0xff);
+         *b = (ubyte) ((p >> 24) & 0xff);
+         *a = (ubyte) ((p >>  0) & 0xff);
+      }
+      return;
+   case PIPE_FORMAT_X8R8G8B8_UNORM:
+      {
+         uint p = uc->ui;
+         *r = (ubyte) ((p >>  8) & 0xff);
+         *g = (ubyte) ((p >> 16) & 0xff);
+         *b = (ubyte) ((p >> 24) & 0xff);
+         *a = (ubyte) 0xff;
+      }
+      return;
+   case PIPE_FORMAT_B5G6R5_UNORM:
+      {
+         ushort p = uc->us;
+         *r = (ubyte) (((p >> 8) & 0xf8) | ((p >> 13) & 0x7));
+         *g = (ubyte) (((p >> 3) & 0xfc) | ((p >>  9) & 0x3));
+         *b = (ubyte) (((p << 3) & 0xf8) | ((p >>  2) & 0x7));
+         *a = (ubyte) 0xff;
+      }
+      return;
+   case PIPE_FORMAT_B5G5R5X1_UNORM:
+      {
+         ushort p = uc->us;
+         *r = (ubyte) (((p >>  7) & 0xf8) | ((p >> 12) & 0x7));
+         *g = (ubyte) (((p >>  2) & 0xf8) | ((p >>  7) & 0x7));
+         *b = (ubyte) (((p <<  3) & 0xf8) | ((p >>  2) & 0x7));
+         *a = (ubyte) 0xff;
+      }
+      return;
+   case PIPE_FORMAT_B5G5R5A1_UNORM:
+      {
+         ushort p = uc->us;
+         *r = (ubyte) (((p >>  7) & 0xf8) | ((p >> 12) & 0x7));
+         *g = (ubyte) (((p >>  2) & 0xf8) | ((p >>  7) & 0x7));
+         *b = (ubyte) (((p <<  3) & 0xf8) | ((p >>  2) & 0x7));
+         *a = (ubyte) (0xff * (p >> 15));
+      }
+      return;
+   case PIPE_FORMAT_B4G4R4A4_UNORM:
+      {
+         ushort p = uc->us;
+         *r = (ubyte) (((p >> 4) & 0xf0) | ((p >>  8) & 0xf));
+         *g = (ubyte) (((p >> 0) & 0xf0) | ((p >>  4) & 0xf));
+         *b = (ubyte) (((p << 4) & 0xf0) | ((p >>  0) & 0xf));
+         *a = (ubyte) (((p >> 8) & 0xf0) | ((p >> 12) & 0xf));
+      }
+      return;
+   case PIPE_FORMAT_A8_UNORM:
+      {
+         ubyte p = uc->ub;
+         *r = *g = *b = (ubyte) 0xff;
+         *a = p;
+      }
+      return;
+   case PIPE_FORMAT_L8_UNORM:
+      {
+         ubyte p = uc->ub;
+         *r = *g = *b = p;
+         *a = (ubyte) 0xff;
+      }
+      return;
+   case PIPE_FORMAT_I8_UNORM:
+      {
+         ubyte p = uc->ub;
+         *r = *g = *b = *a = p;
+      }
+      return;
+   case PIPE_FORMAT_R32G32B32A32_FLOAT:
+      {
+         const float *p = &uc->f[0];
+         *r = float_to_ubyte(p[0]);
+         *g = float_to_ubyte(p[1]);
+         *b = float_to_ubyte(p[2]);
+         *a = float_to_ubyte(p[3]);
+      }
+      return;
+   case PIPE_FORMAT_R32G32B32_FLOAT:
+      {
+         const float *p = &uc->f[0];
+         *r = float_to_ubyte(p[0]);
+         *g = float_to_ubyte(p[1]);
+         *b = float_to_ubyte(p[2]);
+         *a = (ubyte) 0xff;
+      }
+      return;
+
+   case PIPE_FORMAT_R32G32_FLOAT:
+      {
+         const float *p = &uc->f[0];
+         *r = float_to_ubyte(p[0]);
+         *g = float_to_ubyte(p[1]);
+         *b = *a = (ubyte) 0xff;
+      }
+      return;
+
+   case PIPE_FORMAT_R32_FLOAT:
+      {
+         const float *p = &uc->f[0];
+         *r = float_to_ubyte(p[0]);
+         *g = *b = *a = (ubyte) 0xff;
+      }
+      return;
+
+   /* Handle other cases with a generic function.
+    */
+   default:
+      {
+         ubyte dst[4];
+
+         util_format_read_4ub(format, dst, 0, uc, 0, 0, 0, 1, 1);
+         *r = dst[0];
+         *g = dst[1];
+         *b = dst[2];
+         *a = dst[3];
+      }
+   }
+}
+
+
+/**
+ * Note rgba outside [0,1] will be clamped for int pixel formats.
+ */
+static INLINE void
+util_pack_color(const float rgba[4], enum pipe_format format, union util_color *uc)
+{
+   ubyte r = 0;
+   ubyte g = 0;
+   ubyte b = 0;
+   ubyte a = 0;
+
+   if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0) <= 8) {
+      /* format uses 8-bit components or less */
+      r = float_to_ubyte(rgba[0]);
+      g = float_to_ubyte(rgba[1]);
+      b = float_to_ubyte(rgba[2]);
+      a = float_to_ubyte(rgba[3]);
+   }
+
+   switch (format) {
+   case PIPE_FORMAT_A8B8G8R8_UNORM:
+      {
+         uc->ui = (r << 24) | (g << 16) | (b << 8) | a;
+      }
+      return;
+   case PIPE_FORMAT_X8B8G8R8_UNORM:
+      {
+         uc->ui = (r << 24) | (g << 16) | (b << 8) | 0xff;
+      }
+      return;
+   case PIPE_FORMAT_B8G8R8A8_UNORM:
+      {
+         uc->ui = (a << 24) | (r << 16) | (g << 8) | b;
+      }
+      return;
+   case PIPE_FORMAT_B8G8R8X8_UNORM:
+      {
+         uc->ui = (0xff << 24) | (r << 16) | (g << 8) | b;
+      }
+      return;
+   case PIPE_FORMAT_A8R8G8B8_UNORM:
+      {
+         uc->ui = (b << 24) | (g << 16) | (r << 8) | a;
+      }
+      return;
+   case PIPE_FORMAT_X8R8G8B8_UNORM:
+      {
+         uc->ui = (b << 24) | (g << 16) | (r << 8) | 0xff;
+      }
+      return;
+   case PIPE_FORMAT_B5G6R5_UNORM:
+      {
+         uc->us = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | (b >> 3);
+      }
+      return;
+   case PIPE_FORMAT_B5G5R5X1_UNORM:
+      {
+         uc->us = ((0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);
+      }
+      return;
+   case PIPE_FORMAT_B5G5R5A1_UNORM:
+      {
+         uc->us = ((a & 0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);
+      }
+      return;
+   case PIPE_FORMAT_B4G4R4A4_UNORM:
+      {
+         uc->us = ((a & 0xf0) << 8) | ((r & 0xf0) << 4) | ((g & 0xf0) << 0) | (b >> 4);
+      }
+      return;
+   case PIPE_FORMAT_A8_UNORM:
+      {
+         uc->ub = a;
+      }
+      return;
+   case PIPE_FORMAT_L8_UNORM:
+   case PIPE_FORMAT_I8_UNORM:
+      {
+         uc->ub = r;
+      }
+      return;
+   case PIPE_FORMAT_R32G32B32A32_FLOAT:
+      {
+         uc->f[0] = rgba[0];
+         uc->f[1] = rgba[1];
+         uc->f[2] = rgba[2];
+         uc->f[3] = rgba[3];
+      }
+      return;
+   case PIPE_FORMAT_R32G32B32_FLOAT:
+      {
+         uc->f[0] = rgba[0];
+         uc->f[1] = rgba[1];
+         uc->f[2] = rgba[2];
+      }
+      return;
+
+   /* Handle other cases with a generic function.
+    */
+   default:
+      util_format_write_4f(format, rgba, 0, uc, 0, 0, 0, 1, 1);
+   }
+}
+ 
+/* Integer versions of util_pack_z and util_pack_z_stencil - useful for
+ * constructing clear masks.
+ */
+static INLINE uint32_t
+util_pack_mask_z(enum pipe_format format, uint32_t z)
+{
+   switch (format) {
+   case PIPE_FORMAT_Z16_UNORM:
+      return z & 0xffff;
+   case PIPE_FORMAT_Z32_UNORM:
+   case PIPE_FORMAT_Z32_FLOAT:
+      return z;
+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+   case PIPE_FORMAT_Z24X8_UNORM:
+      return z & 0xffffff;
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+   case PIPE_FORMAT_X8Z24_UNORM:
+      return (z & 0xffffff) << 8;
+   case PIPE_FORMAT_S8_USCALED:
+      return 0;
+   default:
+      debug_print_format("gallium: unhandled format in util_pack_mask_z()", format);
+      assert(0);
+      return 0;
+   }
+}
+
+
+static INLINE uint64_t
+util_pack64_mask_z(enum pipe_format format, uint32_t z)
+{
+   switch (format) {
+   case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+      return z;
+   default:
+      return util_pack_mask_z(format, z);
+   }
+}
+
+
+static INLINE uint32_t
+util_pack_mask_z_stencil(enum pipe_format format, uint32_t z, uint8_t s)
+{
+   uint32_t packed = util_pack_mask_z(format, z);
+
+   switch (format) {
+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+      packed |= (uint32_t)s << 24;
+      break;
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+      packed |= s;
+      break;
+   case PIPE_FORMAT_S8_USCALED:
+      packed |= s;
+      break;
+   default:
+      break;
+   }
+
+   return packed;
+}
+
+
+static INLINE uint64_t
+util_pack64_mask_z_stencil(enum pipe_format format, uint32_t z, uint8_t s)
+{
+   uint64_t packed;
+
+   switch (format) {
+   case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+      packed = util_pack64_mask_z(format, z);
+      packed |= (uint64_t)s << 32ull;
+      return packed;
+   default:
+      return util_pack_mask_z_stencil(format, z, s);
+   }
+}
+
+
+/**
+ * Note: it's assumed that z is in [0,1]
+ */
+static INLINE uint32_t
+util_pack_z(enum pipe_format format, double z)
+{
+   union fi fui;
+
+   if (z == 0.0)
+      return 0;
+
+   switch (format) {
+   case PIPE_FORMAT_Z16_UNORM:
+      if (z == 1.0)
+         return 0xffff;
+      return (uint32_t) (z * 0xffff);
+   case PIPE_FORMAT_Z32_UNORM:
+      /* special-case to avoid overflow */
+      if (z == 1.0)
+         return 0xffffffff;
+      return (uint32_t) (z * 0xffffffff);
+   case PIPE_FORMAT_Z32_FLOAT:
+      fui.f = (float)z;
+      return fui.ui;
+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+   case PIPE_FORMAT_Z24X8_UNORM:
+      if (z == 1.0)
+         return 0xffffff;
+      return (uint32_t) (z * 0xffffff);
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+   case PIPE_FORMAT_X8Z24_UNORM:
+      if (z == 1.0)
+         return 0xffffff00;
+      return ((uint32_t) (z * 0xffffff)) << 8;
+   case PIPE_FORMAT_S8_USCALED:
+      /* this case can get it via util_pack_z_stencil() */
+      return 0;
+   default:
+      debug_print_format("gallium: unhandled format in util_pack_z()", format);
+      assert(0);
+      return 0;
+   }
+}
+
+
+static INLINE uint64_t
+util_pack64_z(enum pipe_format format, double z)
+{
+   union fi fui;
+
+   if (z == 0)
+      return 0;
+
+   switch (format) {
+   case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+      fui.f = (float)z;
+      return fui.ui;
+   default:
+      return util_pack_z(format, z);
+   }
+}
+ 
+
+/**
+ * Pack Z and/or stencil values into a 32-bit value described by format.
+ * Note: it's assumed that z is in [0,1] and s in [0,255]
+ */
+static INLINE uint32_t
+util_pack_z_stencil(enum pipe_format format, double z, uint8_t s)
+{
+   uint32_t packed = util_pack_z(format, z);
+
+   switch (format) {
+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+      packed |= (uint32_t)s << 24;
+      break;
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+      packed |= s;
+      break;
+   case PIPE_FORMAT_S8_USCALED:
+      packed |= s;
+      break;
+   default:
+      break;
+   }
+
+   return packed;
+}
+
+
+static INLINE uint64_t
+util_pack64_z_stencil(enum pipe_format format, double z, uint8_t s)
+{
+   uint64_t packed;
+
+   switch (format) {
+   case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+      packed = util_pack64_z(format, z);
+      packed |= (uint64_t)s << 32ull;
+      break;
+   default:
+      return util_pack_z_stencil(format, z, s);
+   }
+
+   return packed;
+}
+
+
+/**
+ * Pack 4 ubytes into a 4-byte word
+ */
+static INLINE unsigned
+pack_ub4(ubyte b0, ubyte b1, ubyte b2, ubyte b3)
+{
+   return ((((unsigned int)b0) << 0) |
+	   (((unsigned int)b1) << 8) |
+	   (((unsigned int)b2) << 16) |
+	   (((unsigned int)b3) << 24));
+}
+
+
+/**
+ * Pack/convert 4 floats into one 4-byte word.
+ */
+static INLINE unsigned
+pack_ui32_float4(float a, float b, float c, float d)
+{
+   return pack_ub4( float_to_ubyte(a),
+		    float_to_ubyte(b),
+		    float_to_ubyte(c),
+		    float_to_ubyte(d) );
+}
+
+
+
+#endif /* U_PACK_COLOR_H */
diff --git a/mesalib/src/gallium/auxiliary/util/u_surface.c b/mesalib/src/gallium/auxiliary/util/u_surface.c
index 26f2aee99..8e123867d 100644
--- a/mesalib/src/gallium/auxiliary/util/u_surface.c
+++ b/mesalib/src/gallium/auxiliary/util/u_surface.c
@@ -1,371 +1,404 @@
-/**************************************************************************

- *

- * Copyright 2009 VMware, Inc.  All Rights Reserved.

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the

- * "Software"), to deal in the Software without restriction, including

- * without limitation the rights to use, copy, modify, merge, publish,

- * distribute, sub license, and/or sell copies of the Software, and to

- * permit persons to whom the Software is furnished to do so, subject to

- * the following conditions:

- *

- * The above copyright notice and this permission notice (including the

- * next paragraph) shall be included in all copies or substantial portions

- * of the Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.

- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR

- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- *

- **************************************************************************/

-

-/**

- * @file

- * Surface utility functions.

- *  

- * @author Brian Paul

- */

-

-

-#include "pipe/p_defines.h"

-#include "pipe/p_screen.h"

-#include "pipe/p_state.h"

-

-#include "util/u_format.h"

-#include "util/u_inlines.h"

-#include "util/u_rect.h"

-#include "util/u_surface.h"

-#include "util/u_pack_color.h"

-

-void

-u_surface_default_template(struct pipe_surface *view,

-                           const struct pipe_resource *texture,

-                           unsigned bind)

-{

-   view->format = texture->format;

-   view->u.tex.level = 0;

-   view->u.tex.first_layer = 0;

-   view->u.tex.last_layer = 0;

-   /* XXX should filter out all non-rt/ds bind flags ? */

-   view->usage = bind;

-}

-

-/**

- * Helper to quickly create an RGBA rendering surface of a certain size.

- * \param textureOut  returns the new texture

- * \param surfaceOut  returns the new surface

- * \return TRUE for success, FALSE if failure

- */

-boolean

-util_create_rgba_surface(struct pipe_context *pipe,

-                         uint width, uint height,

-                         uint bind,

-                         struct pipe_resource **textureOut,

-                         struct pipe_surface **surfaceOut)

-{

-   static const enum pipe_format rgbaFormats[] = {

-      PIPE_FORMAT_B8G8R8A8_UNORM,

-      PIPE_FORMAT_A8R8G8B8_UNORM,

-      PIPE_FORMAT_A8B8G8R8_UNORM,

-      PIPE_FORMAT_NONE

-   };

-   const uint target = PIPE_TEXTURE_2D;

-   enum pipe_format format = PIPE_FORMAT_NONE;

-   struct pipe_resource templ;

-   struct pipe_surface surf_templ;

-   struct pipe_screen *screen = pipe->screen;

-   uint i;

-

-   /* Choose surface format */

-   for (i = 0; rgbaFormats[i]; i++) {

-      if (screen->is_format_supported(screen, rgbaFormats[i],

-                                      target, 0, bind)) {

-         format = rgbaFormats[i];

-         break;

-      }

-   }

-   if (format == PIPE_FORMAT_NONE)

-      return FALSE;  /* unable to get an rgba format!?! */

-

-   /* create texture */

-   memset(&templ, 0, sizeof(templ));

-   templ.target = target;

-   templ.format = format;

-   templ.last_level = 0;

-   templ.width0 = width;

-   templ.height0 = height;

-   templ.depth0 = 1;

-   templ.array_size = 1;

-   templ.bind = bind;

-

-   *textureOut = screen->resource_create(screen, &templ);

-   if (!*textureOut)

-      return FALSE;

-

-   /* create surface */

-   memset(&surf_templ, 0, sizeof(surf_templ));

-   u_surface_default_template(&surf_templ, *textureOut, bind);

-   /* create surface / view into texture */

-   *surfaceOut = pipe->create_surface(pipe,

-                                      *textureOut,

-                                      &surf_templ);

-   if (!*surfaceOut) {

-      pipe_resource_reference(textureOut, NULL);

-      return FALSE;

-   }

-

-   return TRUE;

-}

-

-

-/**

- * Release the surface and texture from util_create_rgba_surface().

- */

-void

-util_destroy_rgba_surface(struct pipe_resource *texture,

-                          struct pipe_surface *surface)

-{

-   pipe_surface_reference(&surface, NULL);

-   pipe_resource_reference(&texture, NULL);

-}

-

-

-

-/**

- * Fallback function for pipe->resource_copy_region().

- * Note: (X,Y)=(0,0) is always the upper-left corner.

- */

-void

-util_resource_copy_region(struct pipe_context *pipe,

-                          struct pipe_resource *dst,

-                          unsigned dst_level,

-                          unsigned dst_x, unsigned dst_y, unsigned dst_z,

-                          struct pipe_resource *src,

-                          unsigned src_level,

-                          const struct pipe_box *src_box)

-{

-   struct pipe_transfer *src_trans, *dst_trans;

-   void *dst_map;

-   const void *src_map;

-   enum pipe_format src_format, dst_format;

-   unsigned w = src_box->width;

-   unsigned h = src_box->height;

-

-   assert(src && dst);

-   assert((src->target == PIPE_BUFFER && dst->target == PIPE_BUFFER) ||

-          (src->target != PIPE_BUFFER && dst->target != PIPE_BUFFER));

-

-   if (!src || !dst)

-      return;

-

-   src_format = src->format;

-   dst_format = dst->format;

-

-   src_trans = pipe_get_transfer(pipe,

-                                 src,

-                                 src_level,

-                                 src_box->z,

-                                 PIPE_TRANSFER_READ,

-                                 src_box->x, src_box->y, w, h);

-

-   dst_trans = pipe_get_transfer(pipe,

-                                 dst,

-                                 dst_level,

-                                 dst_z,

-                                 PIPE_TRANSFER_WRITE,

-                                 dst_x, dst_y, w, h);

-

-   assert(util_format_get_blocksize(dst_format) == util_format_get_blocksize(src_format));

-   assert(util_format_get_blockwidth(dst_format) == util_format_get_blockwidth(src_format));

-   assert(util_format_get_blockheight(dst_format) == util_format_get_blockheight(src_format));

-

-   src_map = pipe->transfer_map(pipe, src_trans);

-   dst_map = pipe->transfer_map(pipe, dst_trans);

-

-   assert(src_map);

-   assert(dst_map);

-

-   if (src_map && dst_map) {

-      if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {

-         memcpy(dst_map, src_map, w);

-      } else {

-         util_copy_rect(dst_map,

-                        dst_format,

-                        dst_trans->stride,

-                        0, 0,

-                        w, h,

-                        src_map,

-                        src_trans->stride,

-                        0,

-                        0);

-      }

-   }

-

-   pipe->transfer_unmap(pipe, src_trans);

-   pipe->transfer_unmap(pipe, dst_trans);

-

-   pipe->transfer_destroy(pipe, src_trans);

-   pipe->transfer_destroy(pipe, dst_trans);

-}

-

-

-

-#define UBYTE_TO_USHORT(B) ((B) | ((B) << 8))

-

-

-/**

- * Fallback for pipe->clear_render_target() function.

- * XXX this looks too hackish to be really useful.

- * cpp > 4 looks like a gross hack at best...

- * Plus can't use these transfer fallbacks when clearing

- * multisampled surfaces for instance.

- */

-void

-util_clear_render_target(struct pipe_context *pipe,

-                         struct pipe_surface *dst,

-                         const float *rgba,

-                         unsigned dstx, unsigned dsty,

-                         unsigned width, unsigned height)

-{

-   struct pipe_transfer *dst_trans;

-   void *dst_map;

-   union util_color uc;

-

-   assert(dst->texture);

-   if (!dst->texture)

-      return;

-   /* XXX: should handle multiple layers */

-   dst_trans = pipe_get_transfer(pipe,

-                                 dst->texture,

-                                 dst->u.tex.level,

-                                 dst->u.tex.first_layer,

-                                 PIPE_TRANSFER_WRITE,

-                                 dstx, dsty, width, height);

-

-   dst_map = pipe->transfer_map(pipe, dst_trans);

-

-   assert(dst_map);

-

-   if (dst_map) {

-      assert(dst_trans->stride > 0);

-

-      util_pack_color(rgba, dst->texture->format, &uc);

-      util_fill_rect(dst_map, dst->texture->format,

-                     dst_trans->stride,

-                     0, 0, width, height, &uc);

-   }

-

-   pipe->transfer_unmap(pipe, dst_trans);

-   pipe->transfer_destroy(pipe, dst_trans);

-}

-

-/**

- * Fallback for pipe->clear_stencil() function.

- * sw fallback doesn't look terribly useful here.

- * Plus can't use these transfer fallbacks when clearing

- * multisampled surfaces for instance.

- */

-void

-util_clear_depth_stencil(struct pipe_context *pipe,

-                         struct pipe_surface *dst,

-                         unsigned clear_flags,

-                         double depth,

-                         unsigned stencil,

-                         unsigned dstx, unsigned dsty,

-                         unsigned width, unsigned height)

-{

-   struct pipe_transfer *dst_trans;

-   ubyte *dst_map;

-   boolean need_rmw = FALSE;

-

-   if ((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) &&

-       ((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&

-       util_format_is_depth_and_stencil(dst->format))

-      need_rmw = TRUE;

-

-   assert(dst->texture);

-   if (!dst->texture)

-      return;

-   dst_trans = pipe_get_transfer(pipe,

-                                 dst->texture,

-                                 dst->u.tex.level,

-                                 dst->u.tex.first_layer,

-                                 (need_rmw ? PIPE_TRANSFER_READ_WRITE :

-                                     PIPE_TRANSFER_WRITE),

-                                 dstx, dsty, width, height);

-

-   dst_map = pipe->transfer_map(pipe, dst_trans);

-

-   assert(dst_map);

-

-   if (dst_map) {

-      unsigned dst_stride = dst_trans->stride;

-      unsigned zstencil = util_pack_z_stencil(dst->texture->format, depth, stencil);

-      unsigned i, j;

-      assert(dst_trans->stride > 0);

-

-      switch (util_format_get_blocksize(dst->format)) {

-      case 1:

-         assert(dst->format == PIPE_FORMAT_S8_USCALED);

-         if(dst_stride == width)

-            memset(dst_map, (ubyte) zstencil, height * width);

-         else {

-            for (i = 0; i < height; i++) {

-               memset(dst_map, (ubyte) zstencil, width);

-               dst_map += dst_stride;

-            }

-         }

-         break;

-      case 2:

-         assert(dst->format == PIPE_FORMAT_Z16_UNORM);

-         for (i = 0; i < height; i++) {

-            uint16_t *row = (uint16_t *)dst_map;

-            for (j = 0; j < width; j++)

-               *row++ = (uint16_t) zstencil;

-            dst_map += dst_stride;

-            }

-         break;

-      case 4:

-         if (!need_rmw) {

-            for (i = 0; i < height; i++) {

-               uint32_t *row = (uint32_t *)dst_map;

-               for (j = 0; j < width; j++)

-                  *row++ = zstencil;

-               dst_map += dst_stride;

-            }

-         }

-         else {

-            uint32_t dst_mask;

-            if (dst->format == PIPE_FORMAT_Z24_UNORM_S8_USCALED)

-               dst_mask = 0xffffff00;

-            else {

-               assert(dst->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM);

-               dst_mask = 0xffffff;

-            }

-            if (clear_flags & PIPE_CLEAR_DEPTH)

-               dst_mask = ~dst_mask;

-            for (i = 0; i < height; i++) {

-               uint32_t *row = (uint32_t *)dst_map;

-               for (j = 0; j < width; j++) {

-                  uint32_t tmp = *row & dst_mask;

-                  *row++ = tmp | (zstencil & ~dst_mask);

-               }

-               dst_map += dst_stride;

-            }

-         }

-        break;

-      case 8:

-      default:

-         assert(0);

-         break;

-      }

-   }

-

-   pipe->transfer_unmap(pipe, dst_trans);

-   pipe->transfer_destroy(pipe, dst_trans);

-}

+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+/**
+ * @file
+ * Surface utility functions.
+ *  
+ * @author Brian Paul
+ */
+
+
+#include "pipe/p_defines.h"
+#include "pipe/p_screen.h"
+#include "pipe/p_state.h"
+
+#include "util/u_format.h"
+#include "util/u_inlines.h"
+#include "util/u_rect.h"
+#include "util/u_surface.h"
+#include "util/u_pack_color.h"
+
+void
+u_surface_default_template(struct pipe_surface *view,
+                           const struct pipe_resource *texture,
+                           unsigned bind)
+{
+   view->format = texture->format;
+   view->u.tex.level = 0;
+   view->u.tex.first_layer = 0;
+   view->u.tex.last_layer = 0;
+   /* XXX should filter out all non-rt/ds bind flags ? */
+   view->usage = bind;
+}
+
+/**
+ * Helper to quickly create an RGBA rendering surface of a certain size.
+ * \param textureOut  returns the new texture
+ * \param surfaceOut  returns the new surface
+ * \return TRUE for success, FALSE if failure
+ */
+boolean
+util_create_rgba_surface(struct pipe_context *pipe,
+                         uint width, uint height,
+                         uint bind,
+                         struct pipe_resource **textureOut,
+                         struct pipe_surface **surfaceOut)
+{
+   static const enum pipe_format rgbaFormats[] = {
+      PIPE_FORMAT_B8G8R8A8_UNORM,
+      PIPE_FORMAT_A8R8G8B8_UNORM,
+      PIPE_FORMAT_A8B8G8R8_UNORM,
+      PIPE_FORMAT_NONE
+   };
+   const uint target = PIPE_TEXTURE_2D;
+   enum pipe_format format = PIPE_FORMAT_NONE;
+   struct pipe_resource templ;
+   struct pipe_surface surf_templ;
+   struct pipe_screen *screen = pipe->screen;
+   uint i;
+
+   /* Choose surface format */
+   for (i = 0; rgbaFormats[i]; i++) {
+      if (screen->is_format_supported(screen, rgbaFormats[i],
+                                      target, 0, bind)) {
+         format = rgbaFormats[i];
+         break;
+      }
+   }
+   if (format == PIPE_FORMAT_NONE)
+      return FALSE;  /* unable to get an rgba format!?! */
+
+   /* create texture */
+   memset(&templ, 0, sizeof(templ));
+   templ.target = target;
+   templ.format = format;
+   templ.last_level = 0;
+   templ.width0 = width;
+   templ.height0 = height;
+   templ.depth0 = 1;
+   templ.array_size = 1;
+   templ.bind = bind;
+
+   *textureOut = screen->resource_create(screen, &templ);
+   if (!*textureOut)
+      return FALSE;
+
+   /* create surface */
+   memset(&surf_templ, 0, sizeof(surf_templ));
+   u_surface_default_template(&surf_templ, *textureOut, bind);
+   /* create surface / view into texture */
+   *surfaceOut = pipe->create_surface(pipe,
+                                      *textureOut,
+                                      &surf_templ);
+   if (!*surfaceOut) {
+      pipe_resource_reference(textureOut, NULL);
+      return FALSE;
+   }
+
+   return TRUE;
+}
+
+
+/**
+ * Release the surface and texture from util_create_rgba_surface().
+ */
+void
+util_destroy_rgba_surface(struct pipe_resource *texture,
+                          struct pipe_surface *surface)
+{
+   pipe_surface_reference(&surface, NULL);
+   pipe_resource_reference(&texture, NULL);
+}
+
+
+
+/**
+ * Fallback function for pipe->resource_copy_region().
+ * Note: (X,Y)=(0,0) is always the upper-left corner.
+ */
+void
+util_resource_copy_region(struct pipe_context *pipe,
+                          struct pipe_resource *dst,
+                          unsigned dst_level,
+                          unsigned dst_x, unsigned dst_y, unsigned dst_z,
+                          struct pipe_resource *src,
+                          unsigned src_level,
+                          const struct pipe_box *src_box)
+{
+   struct pipe_transfer *src_trans, *dst_trans;
+   void *dst_map;
+   const void *src_map;
+   enum pipe_format src_format, dst_format;
+   unsigned w = src_box->width;
+   unsigned h = src_box->height;
+
+   assert(src && dst);
+   assert((src->target == PIPE_BUFFER && dst->target == PIPE_BUFFER) ||
+          (src->target != PIPE_BUFFER && dst->target != PIPE_BUFFER));
+
+   if (!src || !dst)
+      return;
+
+   src_format = src->format;
+   dst_format = dst->format;
+
+   src_trans = pipe_get_transfer(pipe,
+                                 src,
+                                 src_level,
+                                 src_box->z,
+                                 PIPE_TRANSFER_READ,
+                                 src_box->x, src_box->y, w, h);
+
+   dst_trans = pipe_get_transfer(pipe,
+                                 dst,
+                                 dst_level,
+                                 dst_z,
+                                 PIPE_TRANSFER_WRITE,
+                                 dst_x, dst_y, w, h);
+
+   assert(util_format_get_blocksize(dst_format) == util_format_get_blocksize(src_format));
+   assert(util_format_get_blockwidth(dst_format) == util_format_get_blockwidth(src_format));
+   assert(util_format_get_blockheight(dst_format) == util_format_get_blockheight(src_format));
+
+   src_map = pipe->transfer_map(pipe, src_trans);
+   dst_map = pipe->transfer_map(pipe, dst_trans);
+
+   assert(src_map);
+   assert(dst_map);
+
+   if (src_map && dst_map) {
+      if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {
+         memcpy(dst_map, src_map, w);
+      } else {
+         util_copy_rect(dst_map,
+                        dst_format,
+                        dst_trans->stride,
+                        0, 0,
+                        w, h,
+                        src_map,
+                        src_trans->stride,
+                        0,
+                        0);
+      }
+   }
+
+   pipe->transfer_unmap(pipe, src_trans);
+   pipe->transfer_unmap(pipe, dst_trans);
+
+   pipe->transfer_destroy(pipe, src_trans);
+   pipe->transfer_destroy(pipe, dst_trans);
+}
+
+
+
+#define UBYTE_TO_USHORT(B) ((B) | ((B) << 8))
+
+
+/**
+ * Fallback for pipe->clear_render_target() function.
+ * XXX this looks too hackish to be really useful.
+ * cpp > 4 looks like a gross hack at best...
+ * Plus can't use these transfer fallbacks when clearing
+ * multisampled surfaces for instance.
+ */
+void
+util_clear_render_target(struct pipe_context *pipe,
+                         struct pipe_surface *dst,
+                         const float *rgba,
+                         unsigned dstx, unsigned dsty,
+                         unsigned width, unsigned height)
+{
+   struct pipe_transfer *dst_trans;
+   void *dst_map;
+   union util_color uc;
+
+   assert(dst->texture);
+   if (!dst->texture)
+      return;
+   /* XXX: should handle multiple layers */
+   dst_trans = pipe_get_transfer(pipe,
+                                 dst->texture,
+                                 dst->u.tex.level,
+                                 dst->u.tex.first_layer,
+                                 PIPE_TRANSFER_WRITE,
+                                 dstx, dsty, width, height);
+
+   dst_map = pipe->transfer_map(pipe, dst_trans);
+
+   assert(dst_map);
+
+   if (dst_map) {
+      assert(dst_trans->stride > 0);
+
+      util_pack_color(rgba, dst->texture->format, &uc);
+      util_fill_rect(dst_map, dst->texture->format,
+                     dst_trans->stride,
+                     0, 0, width, height, &uc);
+   }
+
+   pipe->transfer_unmap(pipe, dst_trans);
+   pipe->transfer_destroy(pipe, dst_trans);
+}
+
+/**
+ * Fallback for pipe->clear_stencil() function.
+ * sw fallback doesn't look terribly useful here.
+ * Plus can't use these transfer fallbacks when clearing
+ * multisampled surfaces for instance.
+ */
+void
+util_clear_depth_stencil(struct pipe_context *pipe,
+                         struct pipe_surface *dst,
+                         unsigned clear_flags,
+                         double depth,
+                         unsigned stencil,
+                         unsigned dstx, unsigned dsty,
+                         unsigned width, unsigned height)
+{
+   struct pipe_transfer *dst_trans;
+   ubyte *dst_map;
+   boolean need_rmw = FALSE;
+
+   if ((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) &&
+       ((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&
+       util_format_is_depth_and_stencil(dst->format))
+      need_rmw = TRUE;
+
+   assert(dst->texture);
+   if (!dst->texture)
+      return;
+   dst_trans = pipe_get_transfer(pipe,
+                                 dst->texture,
+                                 dst->u.tex.level,
+                                 dst->u.tex.first_layer,
+                                 (need_rmw ? PIPE_TRANSFER_READ_WRITE :
+                                     PIPE_TRANSFER_WRITE),
+                                 dstx, dsty, width, height);
+
+   dst_map = pipe->transfer_map(pipe, dst_trans);
+
+   assert(dst_map);
+
+   if (dst_map) {
+      unsigned dst_stride = dst_trans->stride;
+      unsigned zstencil = util_pack_z_stencil(dst->texture->format, depth, stencil);
+      unsigned i, j;
+      assert(dst_trans->stride > 0);
+
+      switch (util_format_get_blocksize(dst->format)) {
+      case 1:
+         assert(dst->format == PIPE_FORMAT_S8_USCALED);
+         if(dst_stride == width)
+            memset(dst_map, (ubyte) zstencil, height * width);
+         else {
+            for (i = 0; i < height; i++) {
+               memset(dst_map, (ubyte) zstencil, width);
+               dst_map += dst_stride;
+            }
+         }
+         break;
+      case 2:
+         assert(dst->format == PIPE_FORMAT_Z16_UNORM);
+         for (i = 0; i < height; i++) {
+            uint16_t *row = (uint16_t *)dst_map;
+            for (j = 0; j < width; j++)
+               *row++ = (uint16_t) zstencil;
+            dst_map += dst_stride;
+            }
+         break;
+      case 4:
+         if (!need_rmw) {
+            for (i = 0; i < height; i++) {
+               uint32_t *row = (uint32_t *)dst_map;
+               for (j = 0; j < width; j++)
+                  *row++ = zstencil;
+               dst_map += dst_stride;
+            }
+         }
+         else {
+            uint32_t dst_mask;
+            if (dst->format == PIPE_FORMAT_Z24_UNORM_S8_USCALED)
+               dst_mask = 0xffffff00;
+            else {
+               assert(dst->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM);
+               dst_mask = 0xffffff;
+            }
+            if (clear_flags & PIPE_CLEAR_DEPTH)
+               dst_mask = ~dst_mask;
+            for (i = 0; i < height; i++) {
+               uint32_t *row = (uint32_t *)dst_map;
+               for (j = 0; j < width; j++) {
+                  uint32_t tmp = *row & dst_mask;
+                  *row++ = tmp | (zstencil & ~dst_mask);
+               }
+               dst_map += dst_stride;
+            }
+         }
+         break;
+      case 8:
+      {
+         uint64_t zstencil = util_pack64_z_stencil(dst->texture->format,
+                                                   depth, stencil);
+
+         assert(dst->format == PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED);
+
+         if (!need_rmw) {
+            for (i = 0; i < height; i++) {
+               uint64_t *row = (uint64_t *)dst_map;
+               for (j = 0; j < width; j++)
+                  *row++ = zstencil;
+               dst_map += dst_stride;
+            }
+         }
+         else {
+            uint64_t src_mask;
+
+            if (clear_flags & PIPE_CLEAR_DEPTH)
+               src_mask = 0x00000000ffffffffull;
+            else
+               src_mask = 0x000000ff00000000ull;
+
+            for (i = 0; i < height; i++) {
+               uint64_t *row = (uint64_t *)dst_map;
+               for (j = 0; j < width; j++) {
+                  uint64_t tmp = *row & ~src_mask;
+                  *row++ = tmp | (zstencil & src_mask);
+               }
+               dst_map += dst_stride;
+            }
+         }
+         break;
+      }
+      default:
+         assert(0);
+         break;
+      }
+   }
+
+   pipe->transfer_unmap(pipe, dst_trans);
+   pipe->transfer_destroy(pipe, dst_trans);
+}
diff --git a/mesalib/src/gallium/auxiliary/util/u_tile.c b/mesalib/src/gallium/auxiliary/util/u_tile.c
index 54f634948..23f12e5f4 100644
--- a/mesalib/src/gallium/auxiliary/util/u_tile.c
+++ b/mesalib/src/gallium/auxiliary/util/u_tile.c
@@ -1,655 +1,690 @@
-/**************************************************************************

- * 

- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

- * All Rights Reserved.

- * 

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the

- * "Software"), to deal in the Software without restriction, including

- * without limitation the rights to use, copy, modify, merge, publish,

- * distribute, sub license, and/or sell copies of the Software, and to

- * permit persons to whom the Software is furnished to do so, subject to

- * the following conditions:

- * 

- * The above copyright notice and this permission notice (including the

- * next paragraph) shall be included in all copies or substantial portions

- * of the Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.

- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR

- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- * 

- **************************************************************************/

-

-/**

- * RGBA/float tile get/put functions.

- * Usable both by drivers and state trackers.

- */

-

-

-#include "pipe/p_defines.h"

-#include "util/u_inlines.h"

-

-#include "util/u_format.h"

-#include "util/u_math.h"

-#include "util/u_memory.h"

-#include "util/u_rect.h"

-#include "util/u_tile.h"

-

-

-/**

- * Move raw block of pixels from transfer object to user memory.

- */

-void

-pipe_get_tile_raw(struct pipe_context *pipe,

-                  struct pipe_transfer *pt,

-                  uint x, uint y, uint w, uint h,

-                  void *dst, int dst_stride)

-{

-   const void *src;

-

-   if (dst_stride == 0)

-      dst_stride = util_format_get_stride(pt->resource->format, w);

-

-   if (u_clip_tile(x, y, &w, &h, &pt->box))

-      return;

-

-   src = pipe->transfer_map(pipe, pt);

-   assert(src);

-   if(!src)

-      return;

-

-   util_copy_rect(dst, pt->resource->format, dst_stride, 0, 0, w, h, src, pt->stride, x, y);

-

-   pipe->transfer_unmap(pipe, pt);

-}

-

-

-/**

- * Move raw block of pixels from user memory to transfer object.

- */

-void

-pipe_put_tile_raw(struct pipe_context *pipe,

-                  struct pipe_transfer *pt,

-                  uint x, uint y, uint w, uint h,

-                  const void *src, int src_stride)

-{

-   void *dst;

-   enum pipe_format format = pt->resource->format;

-

-   if (src_stride == 0)

-      src_stride = util_format_get_stride(format, w);

-

-   if (u_clip_tile(x, y, &w, &h, &pt->box))

-      return;

-

-   dst = pipe->transfer_map(pipe, pt);

-   assert(dst);

-   if(!dst)

-      return;

-

-   util_copy_rect(dst, format, pt->stride, x, y, w, h, src, src_stride, 0, 0);

-

-   pipe->transfer_unmap(pipe, pt);

-}

-

-

-

-

-/** Convert short in [-32768,32767] to GLfloat in [-1.0,1.0] */

-#define SHORT_TO_FLOAT(S)   ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))

-

-#define UNCLAMPED_FLOAT_TO_SHORT(us, f)  \

-   us = ( (short) ( CLAMP((f), -1.0, 1.0) * 32767.0F) )

-

-

-

-/*** PIPE_FORMAT_Z16_UNORM ***/

-

-/**

- * Return each Z value as four floats in [0,1].

- */

-static void

-z16_get_tile_rgba(const ushort *src,

-                  unsigned w, unsigned h,

-                  float *p,

-                  unsigned dst_stride)

-{

-   const float scale = 1.0f / 65535.0f;

-   unsigned i, j;

-

-   for (i = 0; i < h; i++) {

-      float *pRow = p;

-      for (j = 0; j < w; j++, pRow += 4) {

-         pRow[0] =

-         pRow[1] =

-         pRow[2] =

-         pRow[3] = *src++ * scale;

-      }

-      p += dst_stride;

-   }

-}

-

-

-

-

-/*** PIPE_FORMAT_Z32_UNORM ***/

-

-/**

- * Return each Z value as four floats in [0,1].

- */

-static void

-z32_get_tile_rgba(const unsigned *src,

-                  unsigned w, unsigned h,

-                  float *p,

-                  unsigned dst_stride)

-{

-   const double scale = 1.0 / (double) 0xffffffff;

-   unsigned i, j;

-

-   for (i = 0; i < h; i++) {

-      float *pRow = p;

-      for (j = 0; j < w; j++, pRow += 4) {

-         pRow[0] =

-         pRow[1] =

-         pRow[2] =

-         pRow[3] = (float) (*src++ * scale);

-      }

-      p += dst_stride;

-   }

-}

-

-

-/*** PIPE_FORMAT_Z24_UNORM_S8_USCALED ***/

-

-/**

- * Return Z component as four float in [0,1].  Stencil part ignored.

- */

-static void

-s8z24_get_tile_rgba(const unsigned *src,

-                    unsigned w, unsigned h,

-                    float *p,

-                    unsigned dst_stride)

-{

-   const double scale = 1.0 / ((1 << 24) - 1);

-   unsigned i, j;

-

-   for (i = 0; i < h; i++) {

-      float *pRow = p;

-      for (j = 0; j < w; j++, pRow += 4) {

-         pRow[0] =

-         pRow[1] =

-         pRow[2] =

-         pRow[3] = (float) (scale * (*src++ & 0xffffff));

-      }

-      p += dst_stride;

-   }

-}

-

-

-/*** PIPE_FORMAT_S8_USCALED_Z24_UNORM ***/

-

-/**

- * Return Z component as four float in [0,1].  Stencil part ignored.

- */

-static void

-z24s8_get_tile_rgba(const unsigned *src,

-                    unsigned w, unsigned h,

-                    float *p,

-                    unsigned dst_stride)

-{

-   const double scale = 1.0 / ((1 << 24) - 1);

-   unsigned i, j;

-

-   for (i = 0; i < h; i++) {

-      float *pRow = p;

-      for (j = 0; j < w; j++, pRow += 4) {

-         pRow[0] =

-         pRow[1] =

-         pRow[2] =

-         pRow[3] = (float) (scale * (*src++ >> 8));

-      }

-      p += dst_stride;

-   }

-}

-

-/*** PIPE_FORMAT_S8X24_USCALED ***/

-

-/**

- * Return S component as four uint32_t in [0..255].  Z part ignored.

- */

-static void

-s8x24_get_tile_rgba(const unsigned *src,

-                    unsigned w, unsigned h,

-                    float *p,

-                    unsigned dst_stride)

-{

-   unsigned i, j;

-

-   for (i = 0; i < h; i++) {

-      float *pRow = p;

-

-      for (j = 0; j < w; j++, pRow += 4) {

-         pRow[0] =

-         pRow[1] =

-         pRow[2] =

-         pRow[3] = (float)((*src++ >> 24) & 0xff);

-      }

-

-      p += dst_stride;

-   }

-}

-

-/*** PIPE_FORMAT_X24S8_USCALED ***/

-

-/**

- * Return S component as four uint32_t in [0..255].  Z part ignored.

- */

-static void

-x24s8_get_tile_rgba(const unsigned *src,

-                    unsigned w, unsigned h,

-                    float *p,

-                    unsigned dst_stride)

-{

-   unsigned i, j;

-

-   for (i = 0; i < h; i++) {

-      float *pRow = p;

-      for (j = 0; j < w; j++, pRow += 4) {

-         pRow[0] =

-         pRow[1] =

-         pRow[2] =

-         pRow[3] = (float)(*src++ & 0xff);

-      }

-      p += dst_stride;

-   }

-}

-

-

-/**

- * Return S component as four uint32_t in [0..255].  Z part ignored.

- */

-static void

-s8_get_tile_rgba(const unsigned char *src,

-		 unsigned w, unsigned h,

-		 float *p,

-		 unsigned dst_stride)

-{

-   unsigned i, j;

-

-   for (i = 0; i < h; i++) {

-      float *pRow = p;

-      for (j = 0; j < w; j++, pRow += 4) {

-         pRow[0] =

-         pRow[1] =

-         pRow[2] =

-         pRow[3] = (float)(*src++ & 0xff);

-      }

-      p += dst_stride;

-   }

-}

-

-/*** PIPE_FORMAT_Z32_FLOAT ***/

-

-/**

- * Return each Z value as four floats in [0,1].

- */

-static void

-z32f_get_tile_rgba(const float *src,

-                   unsigned w, unsigned h,

-                   float *p,

-                   unsigned dst_stride)

-{

-   unsigned i, j;

-

-   for (i = 0; i < h; i++) {

-      float *pRow = p;

-      for (j = 0; j < w; j++, pRow += 4) {

-         pRow[0] =

-         pRow[1] =

-         pRow[2] =

-         pRow[3] = *src++;

-      }

-      p += dst_stride;

-   }

-}

-

-

-void

-pipe_tile_raw_to_rgba(enum pipe_format format,

-                      void *src,

-                      uint w, uint h,

-                      float *dst, unsigned dst_stride)

-{

-   switch (format) {

-   case PIPE_FORMAT_Z16_UNORM:

-      z16_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);

-      break;

-   case PIPE_FORMAT_Z32_UNORM:

-      z32_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);

-      break;

-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

-   case PIPE_FORMAT_Z24X8_UNORM:

-      s8z24_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);

-      break;

-   case PIPE_FORMAT_S8_USCALED:

-      s8_get_tile_rgba((unsigned char *) src, w, h, dst, dst_stride);

-      break;

-   case PIPE_FORMAT_X24S8_USCALED:

-      s8x24_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);

-      break;

-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

-   case PIPE_FORMAT_X8Z24_UNORM:

-      z24s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);

-      break;

-   case PIPE_FORMAT_S8X24_USCALED:

-      x24s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);

-      break;

-   case PIPE_FORMAT_Z32_FLOAT:

-      z32f_get_tile_rgba((float *) src, w, h, dst, dst_stride);

-      break;

-   default:

-      util_format_read_4f(format,

-                          dst, dst_stride * sizeof(float),

-                          src, util_format_get_stride(format, w),

-                          0, 0, w, h);

-   }

-}

-

-

-void

-pipe_get_tile_rgba(struct pipe_context *pipe,

-                   struct pipe_transfer *pt,

-                   uint x, uint y, uint w, uint h,

-                   float *p)

-{

-   pipe_get_tile_rgba_format(pipe, pt, x, y, w, h, pt->resource->format, p);

-}

-

-

-void

-pipe_get_tile_rgba_format(struct pipe_context *pipe,

-                          struct pipe_transfer *pt,

-                          uint x, uint y, uint w, uint h,

-                          enum pipe_format format,

-                          float *p)

-{

-   unsigned dst_stride = w * 4;

-   void *packed;

-

-   if (u_clip_tile(x, y, &w, &h, &pt->box)) {

-      return;

-   }

-

-   packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));

-   if (!packed) {

-      return;

-   }

-

-   if (format == PIPE_FORMAT_UYVY || format == PIPE_FORMAT_YUYV) {

-      assert((x & 1) == 0);

-   }

-

-   pipe_get_tile_raw(pipe, pt, x, y, w, h, packed, 0);

-

-   pipe_tile_raw_to_rgba(format, packed, w, h, p, dst_stride);

-

-   FREE(packed);

-}

-

-

-void

-pipe_put_tile_rgba(struct pipe_context *pipe,

-                   struct pipe_transfer *pt,

-                   uint x, uint y, uint w, uint h,

-                   const float *p)

-{

-   pipe_put_tile_rgba_format(pipe, pt, x, y, w, h, pt->resource->format, p);

-}

-

-

-void

-pipe_put_tile_rgba_format(struct pipe_context *pipe,

-                          struct pipe_transfer *pt,

-                          uint x, uint y, uint w, uint h,

-                          enum pipe_format format,

-                          const float *p)

-{

-   unsigned src_stride = w * 4;

-   void *packed;

-

-   if (u_clip_tile(x, y, &w, &h, &pt->box))

-      return;

-

-   packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));

-

-   if (!packed)

-      return;

-

-   switch (format) {

-   case PIPE_FORMAT_Z16_UNORM:

-      /*z16_put_tile_rgba((ushort *) packed, w, h, p, src_stride);*/

-      break;

-   case PIPE_FORMAT_Z32_UNORM:

-      /*z32_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/

-      break;

-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

-   case PIPE_FORMAT_Z24X8_UNORM:

-      /*s8z24_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/

-      break;

-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

-   case PIPE_FORMAT_X8Z24_UNORM:

-      /*z24s8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/

-      break;

-   default:

-      util_format_write_4f(format,

-                           p, src_stride * sizeof(float),

-                           packed, util_format_get_stride(format, w),

-                           0, 0, w, h);

-   }

-

-   pipe_put_tile_raw(pipe, pt, x, y, w, h, packed, 0);

-

-   FREE(packed);

-}

-

-

-/**

- * Get a block of Z values, converted to 32-bit range.

- */

-void

-pipe_get_tile_z(struct pipe_context *pipe,

-                struct pipe_transfer *pt,

-                uint x, uint y, uint w, uint h,

-                uint *z)

-{

-   const uint dstStride = w;

-   ubyte *map;

-   uint *pDest = z;

-   uint i, j;

-   enum pipe_format format = pt->resource->format;

-

-   if (u_clip_tile(x, y, &w, &h, &pt->box))

-      return;

-

-   map = (ubyte *)pipe->transfer_map(pipe, pt);

-   if (!map) {

-      assert(0);

-      return;

-   }

-

-   switch (format) {

-   case PIPE_FORMAT_Z32_UNORM:

-      {

-         const uint *ptrc

-            = (const uint *)(map  + y * pt->stride + x*4);

-         for (i = 0; i < h; i++) {

-            memcpy(pDest, ptrc, 4 * w);

-            pDest += dstStride;

-            ptrc += pt->stride/4;

-         }

-      }

-      break;

-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

-   case PIPE_FORMAT_Z24X8_UNORM:

-      {

-         const uint *ptrc

-            = (const uint *)(map + y * pt->stride + x*4);

-         for (i = 0; i < h; i++) {

-            for (j = 0; j < w; j++) {

-               /* convert 24-bit Z to 32-bit Z */

-               pDest[j] = (ptrc[j] << 8) | ((ptrc[j] >> 16) & 0xff);

-            }

-            pDest += dstStride;

-            ptrc += pt->stride/4;

-         }

-      }

-      break;

-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

-   case PIPE_FORMAT_X8Z24_UNORM:

-      {

-         const uint *ptrc

-            = (const uint *)(map + y * pt->stride + x*4);

-         for (i = 0; i < h; i++) {

-            for (j = 0; j < w; j++) {

-               /* convert 24-bit Z to 32-bit Z */

-               pDest[j] = (ptrc[j] & 0xffffff00) | ((ptrc[j] >> 24) & 0xff);

-            }

-            pDest += dstStride;

-            ptrc += pt->stride/4;

-         }

-      }

-      break;

-   case PIPE_FORMAT_Z16_UNORM:

-      {

-         const ushort *ptrc

-            = (const ushort *)(map + y * pt->stride + x*2);

-         for (i = 0; i < h; i++) {

-            for (j = 0; j < w; j++) {

-               /* convert 16-bit Z to 32-bit Z */

-               pDest[j] = (ptrc[j] << 16) | ptrc[j];

-            }

-            pDest += dstStride;

-            ptrc += pt->stride/2;

-         }

-      }

-      break;

-   default:

-      assert(0);

-   }

-

-   pipe->transfer_unmap(pipe, pt);

-}

-

-

-void

-pipe_put_tile_z(struct pipe_context *pipe,

-                struct pipe_transfer *pt,

-                uint x, uint y, uint w, uint h,

-                const uint *zSrc)

-{

-   const uint srcStride = w;

-   const uint *ptrc = zSrc;

-   ubyte *map;

-   uint i, j;

-   enum pipe_format format = pt->resource->format;

-

-   if (u_clip_tile(x, y, &w, &h, &pt->box))

-      return;

-

-   map = (ubyte *)pipe->transfer_map(pipe, pt);

-   if (!map) {

-      assert(0);

-      return;

-   }

-

-   switch (format) {

-   case PIPE_FORMAT_Z32_UNORM:

-      {

-         uint *pDest = (uint *) (map + y * pt->stride + x*4);

-         for (i = 0; i < h; i++) {

-            memcpy(pDest, ptrc, 4 * w);

-            pDest += pt->stride/4;

-            ptrc += srcStride;

-         }

-      }

-      break;

-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

-      {

-         uint *pDest = (uint *) (map + y * pt->stride + x*4);

-         /*assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);*/

-         for (i = 0; i < h; i++) {

-            for (j = 0; j < w; j++) {

-               /* convert 32-bit Z to 24-bit Z, preserve stencil */

-               pDest[j] = (pDest[j] & 0xff000000) | ptrc[j] >> 8;

-            }

-            pDest += pt->stride/4;

-            ptrc += srcStride;

-         }

-      }

-      break;

-   case PIPE_FORMAT_Z24X8_UNORM:

-      {

-         uint *pDest = (uint *) (map + y * pt->stride + x*4);

-         for (i = 0; i < h; i++) {

-            for (j = 0; j < w; j++) {

-               /* convert 32-bit Z to 24-bit Z (0 stencil) */

-               pDest[j] = ptrc[j] >> 8;

-            }

-            pDest += pt->stride/4;

-            ptrc += srcStride;

-         }

-      }

-      break;

-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

-      {

-         uint *pDest = (uint *) (map + y * pt->stride + x*4);

-         /*assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);*/

-         for (i = 0; i < h; i++) {

-            for (j = 0; j < w; j++) {

-               /* convert 32-bit Z to 24-bit Z, preserve stencil */

-               pDest[j] = (pDest[j] & 0xff) | (ptrc[j] & 0xffffff00);

-            }

-            pDest += pt->stride/4;

-            ptrc += srcStride;

-         }

-      }

-      break;

-   case PIPE_FORMAT_X8Z24_UNORM:

-      {

-         uint *pDest = (uint *) (map + y * pt->stride + x*4);

-         for (i = 0; i < h; i++) {

-            for (j = 0; j < w; j++) {

-               /* convert 32-bit Z to 24-bit Z (0 stencil) */

-               pDest[j] = ptrc[j] & 0xffffff00;

-            }

-            pDest += pt->stride/4;

-            ptrc += srcStride;

-         }

-      }

-      break;

-   case PIPE_FORMAT_Z16_UNORM:

-      {

-         ushort *pDest = (ushort *) (map + y * pt->stride + x*2);

-         for (i = 0; i < h; i++) {

-            for (j = 0; j < w; j++) {

-               /* convert 32-bit Z to 16-bit Z */

-               pDest[j] = ptrc[j] >> 16;

-            }

-            pDest += pt->stride/2;

-            ptrc += srcStride;

-         }

-      }

-      break;

-   default:

-      assert(0);

-   }

-

-   pipe->transfer_unmap(pipe, pt);

-}

-

-

+/**************************************************************************
+ * 
+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ **************************************************************************/
+
+/**
+ * RGBA/float tile get/put functions.
+ * Usable both by drivers and state trackers.
+ */
+
+
+#include "pipe/p_defines.h"
+#include "util/u_inlines.h"
+
+#include "util/u_format.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
+#include "util/u_rect.h"
+#include "util/u_tile.h"
+
+
+/**
+ * Move raw block of pixels from transfer object to user memory.
+ */
+void
+pipe_get_tile_raw(struct pipe_context *pipe,
+                  struct pipe_transfer *pt,
+                  uint x, uint y, uint w, uint h,
+                  void *dst, int dst_stride)
+{
+   const void *src;
+
+   if (dst_stride == 0)
+      dst_stride = util_format_get_stride(pt->resource->format, w);
+
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
+      return;
+
+   src = pipe->transfer_map(pipe, pt);
+   assert(src);
+   if(!src)
+      return;
+
+   util_copy_rect(dst, pt->resource->format, dst_stride, 0, 0, w, h, src, pt->stride, x, y);
+
+   pipe->transfer_unmap(pipe, pt);
+}
+
+
+/**
+ * Move raw block of pixels from user memory to transfer object.
+ */
+void
+pipe_put_tile_raw(struct pipe_context *pipe,
+                  struct pipe_transfer *pt,
+                  uint x, uint y, uint w, uint h,
+                  const void *src, int src_stride)
+{
+   void *dst;
+   enum pipe_format format = pt->resource->format;
+
+   if (src_stride == 0)
+      src_stride = util_format_get_stride(format, w);
+
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
+      return;
+
+   dst = pipe->transfer_map(pipe, pt);
+   assert(dst);
+   if(!dst)
+      return;
+
+   util_copy_rect(dst, format, pt->stride, x, y, w, h, src, src_stride, 0, 0);
+
+   pipe->transfer_unmap(pipe, pt);
+}
+
+
+
+
+/** Convert short in [-32768,32767] to GLfloat in [-1.0,1.0] */
+#define SHORT_TO_FLOAT(S)   ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))
+
+#define UNCLAMPED_FLOAT_TO_SHORT(us, f)  \
+   us = ( (short) ( CLAMP((f), -1.0, 1.0) * 32767.0F) )
+
+
+
+/*** PIPE_FORMAT_Z16_UNORM ***/
+
+/**
+ * Return each Z value as four floats in [0,1].
+ */
+static void
+z16_get_tile_rgba(const ushort *src,
+                  unsigned w, unsigned h,
+                  float *p,
+                  unsigned dst_stride)
+{
+   const float scale = 1.0f / 65535.0f;
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] =
+         pRow[1] =
+         pRow[2] =
+         pRow[3] = *src++ * scale;
+      }
+      p += dst_stride;
+   }
+}
+
+
+
+
+/*** PIPE_FORMAT_Z32_UNORM ***/
+
+/**
+ * Return each Z value as four floats in [0,1].
+ */
+static void
+z32_get_tile_rgba(const unsigned *src,
+                  unsigned w, unsigned h,
+                  float *p,
+                  unsigned dst_stride)
+{
+   const double scale = 1.0 / (double) 0xffffffff;
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] =
+         pRow[1] =
+         pRow[2] =
+         pRow[3] = (float) (*src++ * scale);
+      }
+      p += dst_stride;
+   }
+}
+
+
+/*** PIPE_FORMAT_Z24_UNORM_S8_USCALED ***/
+
+/**
+ * Return Z component as four float in [0,1].  Stencil part ignored.
+ */
+static void
+s8z24_get_tile_rgba(const unsigned *src,
+                    unsigned w, unsigned h,
+                    float *p,
+                    unsigned dst_stride)
+{
+   const double scale = 1.0 / ((1 << 24) - 1);
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] =
+         pRow[1] =
+         pRow[2] =
+         pRow[3] = (float) (scale * (*src++ & 0xffffff));
+      }
+      p += dst_stride;
+   }
+}
+
+
+/*** PIPE_FORMAT_S8_USCALED_Z24_UNORM ***/
+
+/**
+ * Return Z component as four float in [0,1].  Stencil part ignored.
+ */
+static void
+z24s8_get_tile_rgba(const unsigned *src,
+                    unsigned w, unsigned h,
+                    float *p,
+                    unsigned dst_stride)
+{
+   const double scale = 1.0 / ((1 << 24) - 1);
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] =
+         pRow[1] =
+         pRow[2] =
+         pRow[3] = (float) (scale * (*src++ >> 8));
+      }
+      p += dst_stride;
+   }
+}
+
+/*** PIPE_FORMAT_S8X24_USCALED ***/
+
+/**
+ * Return S component as four uint32_t in [0..255].  Z part ignored.
+ */
+static void
+s8x24_get_tile_rgba(const unsigned *src,
+                    unsigned w, unsigned h,
+                    float *p,
+                    unsigned dst_stride)
+{
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] =
+         pRow[1] =
+         pRow[2] =
+         pRow[3] = (float)((*src++ >> 24) & 0xff);
+      }
+
+      p += dst_stride;
+   }
+}
+
+/*** PIPE_FORMAT_X24S8_USCALED ***/
+
+/**
+ * Return S component as four uint32_t in [0..255].  Z part ignored.
+ */
+static void
+x24s8_get_tile_rgba(const unsigned *src,
+                    unsigned w, unsigned h,
+                    float *p,
+                    unsigned dst_stride)
+{
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] =
+         pRow[1] =
+         pRow[2] =
+         pRow[3] = (float)(*src++ & 0xff);
+      }
+      p += dst_stride;
+   }
+}
+
+
+/**
+ * Return S component as four uint32_t in [0..255].  Z part ignored.
+ */
+static void
+s8_get_tile_rgba(const unsigned char *src,
+		 unsigned w, unsigned h,
+		 float *p,
+		 unsigned dst_stride)
+{
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] =
+         pRow[1] =
+         pRow[2] =
+         pRow[3] = (float)(*src++ & 0xff);
+      }
+      p += dst_stride;
+   }
+}
+
+/*** PIPE_FORMAT_Z32_FLOAT ***/
+
+/**
+ * Return each Z value as four floats in [0,1].
+ */
+static void
+z32f_get_tile_rgba(const float *src,
+                   unsigned w, unsigned h,
+                   float *p,
+                   unsigned dst_stride)
+{
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] =
+         pRow[1] =
+         pRow[2] =
+         pRow[3] = *src++;
+      }
+      p += dst_stride;
+   }
+}
+
+/*** PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED ***/
+
+/**
+ * Return each Z value as four floats in [0,1].
+ */
+static void
+z32f_x24s8_get_tile_rgba(const float *src,
+                         unsigned w, unsigned h,
+                         float *p,
+                         unsigned dst_stride)
+{
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] =
+         pRow[1] =
+         pRow[2] =
+         pRow[3] = *src;
+         src += 2;
+      }
+      p += dst_stride;
+   }
+}
+
+
+void
+pipe_tile_raw_to_rgba(enum pipe_format format,
+                      void *src,
+                      uint w, uint h,
+                      float *dst, unsigned dst_stride)
+{
+   switch (format) {
+   case PIPE_FORMAT_Z16_UNORM:
+      z16_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
+      break;
+   case PIPE_FORMAT_Z32_UNORM:
+      z32_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
+      break;
+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+   case PIPE_FORMAT_Z24X8_UNORM:
+      s8z24_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
+      break;
+   case PIPE_FORMAT_S8_USCALED:
+      s8_get_tile_rgba((unsigned char *) src, w, h, dst, dst_stride);
+      break;
+   case PIPE_FORMAT_X24S8_USCALED:
+      s8x24_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
+      break;
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+   case PIPE_FORMAT_X8Z24_UNORM:
+      z24s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
+      break;
+   case PIPE_FORMAT_S8X24_USCALED:
+      x24s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
+      break;
+   case PIPE_FORMAT_Z32_FLOAT:
+      z32f_get_tile_rgba((float *) src, w, h, dst, dst_stride);
+      break;
+   case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+      z32f_x24s8_get_tile_rgba((float *) src, w, h, dst, dst_stride);
+      break;
+   default:
+      util_format_read_4f(format,
+                          dst, dst_stride * sizeof(float),
+                          src, util_format_get_stride(format, w),
+                          0, 0, w, h);
+   }
+}
+
+
+void
+pipe_get_tile_rgba(struct pipe_context *pipe,
+                   struct pipe_transfer *pt,
+                   uint x, uint y, uint w, uint h,
+                   float *p)
+{
+   pipe_get_tile_rgba_format(pipe, pt, x, y, w, h, pt->resource->format, p);
+}
+
+
+void
+pipe_get_tile_rgba_format(struct pipe_context *pipe,
+                          struct pipe_transfer *pt,
+                          uint x, uint y, uint w, uint h,
+                          enum pipe_format format,
+                          float *p)
+{
+   unsigned dst_stride = w * 4;
+   void *packed;
+
+   if (u_clip_tile(x, y, &w, &h, &pt->box)) {
+      return;
+   }
+
+   packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
+   if (!packed) {
+      return;
+   }
+
+   if (format == PIPE_FORMAT_UYVY || format == PIPE_FORMAT_YUYV) {
+      assert((x & 1) == 0);
+   }
+
+   pipe_get_tile_raw(pipe, pt, x, y, w, h, packed, 0);
+
+   pipe_tile_raw_to_rgba(format, packed, w, h, p, dst_stride);
+
+   FREE(packed);
+}
+
+
+void
+pipe_put_tile_rgba(struct pipe_context *pipe,
+                   struct pipe_transfer *pt,
+                   uint x, uint y, uint w, uint h,
+                   const float *p)
+{
+   pipe_put_tile_rgba_format(pipe, pt, x, y, w, h, pt->resource->format, p);
+}
+
+
+void
+pipe_put_tile_rgba_format(struct pipe_context *pipe,
+                          struct pipe_transfer *pt,
+                          uint x, uint y, uint w, uint h,
+                          enum pipe_format format,
+                          const float *p)
+{
+   unsigned src_stride = w * 4;
+   void *packed;
+
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
+      return;
+
+   packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
+
+   if (!packed)
+      return;
+
+   switch (format) {
+   case PIPE_FORMAT_Z16_UNORM:
+      /*z16_put_tile_rgba((ushort *) packed, w, h, p, src_stride);*/
+      break;
+   case PIPE_FORMAT_Z32_UNORM:
+      /*z32_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
+      break;
+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+   case PIPE_FORMAT_Z24X8_UNORM:
+      /*s8z24_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
+      break;
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+   case PIPE_FORMAT_X8Z24_UNORM:
+      /*z24s8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
+      break;
+   case PIPE_FORMAT_Z32_FLOAT:
+      /*z32f_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
+      break;
+   case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+      /*z32f_s8x24_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
+      break;
+   default:
+      util_format_write_4f(format,
+                           p, src_stride * sizeof(float),
+                           packed, util_format_get_stride(format, w),
+                           0, 0, w, h);
+   }
+
+   pipe_put_tile_raw(pipe, pt, x, y, w, h, packed, 0);
+
+   FREE(packed);
+}
+
+
+/**
+ * Get a block of Z values, converted to 32-bit range.
+ */
+void
+pipe_get_tile_z(struct pipe_context *pipe,
+                struct pipe_transfer *pt,
+                uint x, uint y, uint w, uint h,
+                uint *z)
+{
+   const uint dstStride = w;
+   ubyte *map;
+   uint *pDest = z;
+   uint i, j;
+   enum pipe_format format = pt->resource->format;
+
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
+      return;
+
+   map = (ubyte *)pipe->transfer_map(pipe, pt);
+   if (!map) {
+      assert(0);
+      return;
+   }
+
+   switch (format) {
+   case PIPE_FORMAT_Z32_UNORM:
+      {
+         const uint *ptrc
+            = (const uint *)(map  + y * pt->stride + x*4);
+         for (i = 0; i < h; i++) {
+            memcpy(pDest, ptrc, 4 * w);
+            pDest += dstStride;
+            ptrc += pt->stride/4;
+         }
+      }
+      break;
+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+   case PIPE_FORMAT_Z24X8_UNORM:
+      {
+         const uint *ptrc
+            = (const uint *)(map + y * pt->stride + x*4);
+         for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+               /* convert 24-bit Z to 32-bit Z */
+               pDest[j] = (ptrc[j] << 8) | ((ptrc[j] >> 16) & 0xff);
+            }
+            pDest += dstStride;
+            ptrc += pt->stride/4;
+         }
+      }
+      break;
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+   case PIPE_FORMAT_X8Z24_UNORM:
+      {
+         const uint *ptrc
+            = (const uint *)(map + y * pt->stride + x*4);
+         for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+               /* convert 24-bit Z to 32-bit Z */
+               pDest[j] = (ptrc[j] & 0xffffff00) | ((ptrc[j] >> 24) & 0xff);
+            }
+            pDest += dstStride;
+            ptrc += pt->stride/4;
+         }
+      }
+      break;
+   case PIPE_FORMAT_Z16_UNORM:
+      {
+         const ushort *ptrc
+            = (const ushort *)(map + y * pt->stride + x*2);
+         for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+               /* convert 16-bit Z to 32-bit Z */
+               pDest[j] = (ptrc[j] << 16) | ptrc[j];
+            }
+            pDest += dstStride;
+            ptrc += pt->stride/2;
+         }
+      }
+      break;
+   default:
+      assert(0);
+   }
+
+   pipe->transfer_unmap(pipe, pt);
+}
+
+
+void
+pipe_put_tile_z(struct pipe_context *pipe,
+                struct pipe_transfer *pt,
+                uint x, uint y, uint w, uint h,
+                const uint *zSrc)
+{
+   const uint srcStride = w;
+   const uint *ptrc = zSrc;
+   ubyte *map;
+   uint i, j;
+   enum pipe_format format = pt->resource->format;
+
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
+      return;
+
+   map = (ubyte *)pipe->transfer_map(pipe, pt);
+   if (!map) {
+      assert(0);
+      return;
+   }
+
+   switch (format) {
+   case PIPE_FORMAT_Z32_UNORM:
+      {
+         uint *pDest = (uint *) (map + y * pt->stride + x*4);
+         for (i = 0; i < h; i++) {
+            memcpy(pDest, ptrc, 4 * w);
+            pDest += pt->stride/4;
+            ptrc += srcStride;
+         }
+      }
+      break;
+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+      {
+         uint *pDest = (uint *) (map + y * pt->stride + x*4);
+         /*assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);*/
+         for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+               /* convert 32-bit Z to 24-bit Z, preserve stencil */
+               pDest[j] = (pDest[j] & 0xff000000) | ptrc[j] >> 8;
+            }
+            pDest += pt->stride/4;
+            ptrc += srcStride;
+         }
+      }
+      break;
+   case PIPE_FORMAT_Z24X8_UNORM:
+      {
+         uint *pDest = (uint *) (map + y * pt->stride + x*4);
+         for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+               /* convert 32-bit Z to 24-bit Z (0 stencil) */
+               pDest[j] = ptrc[j] >> 8;
+            }
+            pDest += pt->stride/4;
+            ptrc += srcStride;
+         }
+      }
+      break;
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+      {
+         uint *pDest = (uint *) (map + y * pt->stride + x*4);
+         /*assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);*/
+         for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+               /* convert 32-bit Z to 24-bit Z, preserve stencil */
+               pDest[j] = (pDest[j] & 0xff) | (ptrc[j] & 0xffffff00);
+            }
+            pDest += pt->stride/4;
+            ptrc += srcStride;
+         }
+      }
+      break;
+   case PIPE_FORMAT_X8Z24_UNORM:
+      {
+         uint *pDest = (uint *) (map + y * pt->stride + x*4);
+         for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+               /* convert 32-bit Z to 24-bit Z (0 stencil) */
+               pDest[j] = ptrc[j] & 0xffffff00;
+            }
+            pDest += pt->stride/4;
+            ptrc += srcStride;
+         }
+      }
+      break;
+   case PIPE_FORMAT_Z16_UNORM:
+      {
+         ushort *pDest = (ushort *) (map + y * pt->stride + x*2);
+         for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+               /* convert 32-bit Z to 16-bit Z */
+               pDest[j] = ptrc[j] >> 16;
+            }
+            pDest += pt->stride/2;
+            ptrc += srcStride;
+         }
+      }
+      break;
+   default:
+      assert(0);
+   }
+
+   pipe->transfer_unmap(pipe, pt);
+}
+
+