libX11 mesa mkfontscale pixman xserver git update 29 Mar 2011

7 files changed, 824 insertions, 816 deletions

diff --git a/mesalib/src/mesa/state_tracker/st_atom_pixeltransfer.c b/mesalib/src/mesa/state_tracker/st_atom_pixeltransfer.c
index 57430b36f..95b706cb9 100644
--- a/mesalib/src/mesa/state_tracker/st_atom_pixeltransfer.c
+++ b/mesalib/src/mesa/state_tracker/st_atom_pixeltransfer.c
@@ -121,7 +121,7 @@ load_color_map_texture(struct gl_context *ctx, struct pipe_resource *pt)
    uint *dest;
    uint i, j;
 
-   transfer = pipe_get_transfer(st_context(ctx)->pipe,
+   transfer = pipe_get_transfer(pipe,
                                 pt, 0, 0, PIPE_TRANSFER_WRITE,
                                 0, 0, texSize, texSize);
    dest = (uint *) pipe_transfer_map(pipe, transfer);
diff --git a/mesalib/src/mesa/state_tracker/st_cb_accum.c b/mesalib/src/mesa/state_tracker/st_cb_accum.c
index 66e5312d9..3e3659d15 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_accum.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_accum.c
@@ -1,347 +1,347 @@
-/**************************************************************************

- * 

- * 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.

- * 

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

-

- /*

-  * Authors:

-  *   Brian Paul

-  */

-

-#include "main/imports.h"

-#include "main/image.h"

-#include "main/macros.h"

-#include "main/mfeatures.h"

-

-#include "st_debug.h"

-#include "st_context.h"

-#include "st_cb_accum.h"

-#include "st_cb_fbo.h"

-#include "st_texture.h"

-#include "pipe/p_context.h"

-#include "pipe/p_defines.h"

-#include "util/u_format.h"

-#include "util/u_inlines.h"

-#include "util/u_tile.h"

-

-

-#if FEATURE_accum

-

-/**

- * For hardware that supports deep color buffers, we could accelerate

- * most/all the accum operations with blending/texturing.

- * For now, just use the get/put_tile() functions and do things in software.

- */

-

-

-void

-st_clear_accum_buffer(struct gl_context *ctx, struct gl_renderbuffer *rb)

-{

-   struct st_renderbuffer *acc_strb = st_renderbuffer(rb);

-   const GLint xpos = ctx->DrawBuffer->_Xmin;

-   const GLint ypos = ctx->DrawBuffer->_Ymin;

-   const GLint width = ctx->DrawBuffer->_Xmax - xpos;

-   const GLint height = ctx->DrawBuffer->_Ymax - ypos;

-   size_t stride = acc_strb->stride;

-   GLubyte *data = acc_strb->data;

-

-   if(!data)

-      return;

-   

-   switch (acc_strb->format) {

-   case PIPE_FORMAT_R16G16B16A16_SNORM:

-      {

-         GLshort r = FLOAT_TO_SHORT(ctx->Accum.ClearColor[0]);

-         GLshort g = FLOAT_TO_SHORT(ctx->Accum.ClearColor[1]);

-         GLshort b = FLOAT_TO_SHORT(ctx->Accum.ClearColor[2]);

-         GLshort a = FLOAT_TO_SHORT(ctx->Accum.ClearColor[3]);

-         int i, j;

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

-            GLshort *dst = (GLshort *) (data + (ypos + i) * stride + xpos * 8);

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

-               dst[0] = r;

-               dst[1] = g;

-               dst[2] = b;

-               dst[3] = a;

-               dst += 4;

-            }

-         }

-      }

-      break;

-   default:

-      _mesa_problem(ctx, "unexpected format in st_clear_accum_buffer()");

-   }

-}

-

-

-/** For ADD/MULT */

-static void

-accum_mad(struct gl_context *ctx, GLfloat scale, GLfloat bias,

-          GLint xpos, GLint ypos, GLint width, GLint height,

-          struct st_renderbuffer *acc_strb)

-{

-   size_t stride = acc_strb->stride;

-   GLubyte *data = acc_strb->data;

-

-   switch (acc_strb->format) {

-   case PIPE_FORMAT_R16G16B16A16_SNORM:

-      {

-         int i, j;

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

-            GLshort *acc = (GLshort *) (data + (ypos + i) * stride + xpos * 8);

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

-               float val = SHORT_TO_FLOAT(*acc) * scale + bias;

-               *acc++ = FLOAT_TO_SHORT(val);

-            }

-         }

-      }

-      break;

-   default:

-      _mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");

-   }

-}

-

-

-static void

-accum_accum(struct st_context *st, GLfloat value,

-            GLint xpos, GLint ypos, GLint width, GLint height,

-            struct st_renderbuffer *acc_strb,

-            struct st_renderbuffer *color_strb)

-{

-   struct pipe_context *pipe = st->pipe;

-   struct pipe_transfer *color_trans;

-   size_t stride = acc_strb->stride;

-   GLubyte *data = acc_strb->data;

-   GLfloat *buf;

-

-   if (ST_DEBUG & DEBUG_FALLBACK)

-      debug_printf("%s: fallback processing\n", __FUNCTION__);

-

-   color_trans = pipe_get_transfer(st->pipe,

-                                   color_strb->texture,

-                                   0, 0,

-                                   PIPE_TRANSFER_READ, xpos, ypos,

-                                   width, height);

-

-   buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));

-

-   pipe_get_tile_rgba_format(pipe, color_trans, 0, 0, width, height,

-                             util_format_linear(color_strb->texture->format),

-                             buf);

-

-   switch (acc_strb->format) {

-   case PIPE_FORMAT_R16G16B16A16_SNORM:

-      {

-         const GLfloat *color = buf;

-         int i, j;

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

-            GLshort *acc = (GLshort *) (data + (ypos + i) * stride + xpos * 8);

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

-               float val = *color++ * value;

-               *acc++ += FLOAT_TO_SHORT(val);

-            }

-         }

-      }

-      break;

-   default:

-      _mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");

-   }

-

-   free(buf);

-   pipe->transfer_destroy(pipe, color_trans);

-}

-

-

-static void

-accum_load(struct st_context *st, GLfloat value,

-           GLint xpos, GLint ypos, GLint width, GLint height,

-           struct st_renderbuffer *acc_strb,

-           struct st_renderbuffer *color_strb)

-{

-   struct pipe_context *pipe = st->pipe;

-   struct pipe_transfer *color_trans;

-   size_t stride = acc_strb->stride;

-   GLubyte *data = acc_strb->data;

-   GLfloat *buf;

-

-   if (ST_DEBUG & DEBUG_FALLBACK)

-      debug_printf("%s: fallback processing\n", __FUNCTION__);

-

-   color_trans = pipe_get_transfer(st->pipe, color_strb->texture,

-                                   0, 0,

-                                   PIPE_TRANSFER_READ, xpos, ypos,

-                                   width, height);

-

-   buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));

-

-   pipe_get_tile_rgba_format(pipe, color_trans, 0, 0, width, height,

-                             util_format_linear(color_strb->texture->format),

-                             buf);

-

-   switch (acc_strb->format) {

-   case PIPE_FORMAT_R16G16B16A16_SNORM:

-      {

-         const GLfloat *color = buf;

-         int i, j;

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

-            GLshort *acc = (GLshort *) (data + (ypos + i) * stride + xpos * 8);

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

-               float val = *color++ * value;

-               *acc++ = FLOAT_TO_SHORT(val);

-            }

-         }

-      }

-      break;

-   default:

-      _mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");

-   }

-

-   free(buf);

-   pipe->transfer_destroy(pipe, color_trans);

-}

-

-

-static void

-accum_return(struct gl_context *ctx, GLfloat value,

-             GLint xpos, GLint ypos, GLint width, GLint height,

-             struct st_renderbuffer *acc_strb,

-             struct st_renderbuffer *color_strb)

-{

-   struct pipe_context *pipe = st_context(ctx)->pipe;

-   const GLubyte *colormask = ctx->Color.ColorMask[0];

-   enum pipe_transfer_usage usage;

-   struct pipe_transfer *color_trans;

-   size_t stride = acc_strb->stride;

-   const GLubyte *data = acc_strb->data;

-   GLfloat *buf;

-   enum pipe_format format = util_format_linear(color_strb->texture->format);

-

-   if (ST_DEBUG & DEBUG_FALLBACK)

-      debug_printf("%s: fallback processing\n", __FUNCTION__);

-

-   buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));

-

-   if (!colormask[0] || !colormask[1] || !colormask[2] || !colormask[3])

-      usage = PIPE_TRANSFER_READ_WRITE;

-   else

-      usage = PIPE_TRANSFER_WRITE;

-

-   color_trans = pipe_get_transfer(st_context(ctx)->pipe,

-                                   color_strb->texture, 0, 0,

-                                   usage,

-                                   xpos, ypos,

-                                   width, height);

-

-   if (usage & PIPE_TRANSFER_READ)

-      pipe_get_tile_rgba_format(pipe, color_trans, 0, 0, width, height,

-                                format, buf);

-

-   switch (acc_strb->format) {

-   case PIPE_FORMAT_R16G16B16A16_SNORM:

-      {

-         GLfloat *color = buf;

-         int i, j, ch;

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

-            const GLshort *acc = (const GLshort *) (data + (ypos + i) * stride + xpos * 8);

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

-               for (ch = 0; ch < 4; ch++) {

-                  if (colormask[ch]) {

-                     GLfloat val = SHORT_TO_FLOAT(*acc * value);

-                     *color = CLAMP(val, 0.0f, 1.0f);

-                  }

-                  else {

-                     /* No change */

-                  }

-                  ++acc;

-                  ++color;

-               }

-            }

-         }

-      }

-      break;

-   default:

-      _mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");

-   }

-

-   pipe_put_tile_rgba_format(pipe, color_trans, 0, 0, width, height,

-                             format, buf);

-

-   free(buf);

-   pipe->transfer_destroy(pipe, color_trans);

-}

-

-

-static void

-st_Accum(struct gl_context *ctx, GLenum op, GLfloat value)

-{

-   struct st_context *st = st_context(ctx);

-   struct st_renderbuffer *acc_strb

-     = st_renderbuffer(ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer);

-   struct st_renderbuffer *color_strb

-      = st_renderbuffer(ctx->ReadBuffer->_ColorReadBuffer);

-

-   const GLint xpos = ctx->DrawBuffer->_Xmin;

-   const GLint ypos = ctx->DrawBuffer->_Ymin;

-   const GLint width = ctx->DrawBuffer->_Xmax - xpos;

-   const GLint height = ctx->DrawBuffer->_Ymax - ypos;

-

-   if(!acc_strb->data)

-      return;

-   

-   switch (op) {

-   case GL_ADD:

-      if (value != 0.0F) {

-         accum_mad(ctx, 1.0, value, xpos, ypos, width, height, acc_strb);

-      }

-      break;

-   case GL_MULT:

-      if (value != 1.0F) {

-         accum_mad(ctx, value, 0.0, xpos, ypos, width, height, acc_strb);

-      }

-      break;

-   case GL_ACCUM:

-      if (value != 0.0F) {

-         accum_accum(st, value, xpos, ypos, width, height, acc_strb, color_strb);

-      }

-      break;

-   case GL_LOAD:

-      accum_load(st, value, xpos, ypos, width, height, acc_strb, color_strb);

-      break;

-   case GL_RETURN:

-      accum_return(ctx, value, xpos, ypos, width, height, acc_strb, color_strb);

-      break;

-   default:

-      assert(0);

-   }

-}

-

-

-

-void st_init_accum_functions(struct dd_function_table *functions)

-{

-   functions->Accum = st_Accum;

-}

-

-#endif /* FEATURE_accum */

+/**************************************************************************
+ * 
+ * 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.
+ * 
+ **************************************************************************/
+
+ /*
+  * Authors:
+  *   Brian Paul
+  */
+
+#include "main/imports.h"
+#include "main/image.h"
+#include "main/macros.h"
+#include "main/mfeatures.h"
+
+#include "st_debug.h"
+#include "st_context.h"
+#include "st_cb_accum.h"
+#include "st_cb_fbo.h"
+#include "st_texture.h"
+#include "pipe/p_context.h"
+#include "pipe/p_defines.h"
+#include "util/u_format.h"
+#include "util/u_inlines.h"
+#include "util/u_tile.h"
+
+
+#if FEATURE_accum
+
+/**
+ * For hardware that supports deep color buffers, we could accelerate
+ * most/all the accum operations with blending/texturing.
+ * For now, just use the get/put_tile() functions and do things in software.
+ */
+
+
+void
+st_clear_accum_buffer(struct gl_context *ctx, struct gl_renderbuffer *rb)
+{
+   struct st_renderbuffer *acc_strb = st_renderbuffer(rb);
+   const GLint xpos = ctx->DrawBuffer->_Xmin;
+   const GLint ypos = ctx->DrawBuffer->_Ymin;
+   const GLint width = ctx->DrawBuffer->_Xmax - xpos;
+   const GLint height = ctx->DrawBuffer->_Ymax - ypos;
+   size_t stride = acc_strb->stride;
+   GLubyte *data = acc_strb->data;
+
+   if(!data)
+      return;
+   
+   switch (acc_strb->format) {
+   case PIPE_FORMAT_R16G16B16A16_SNORM:
+      {
+         GLshort r = FLOAT_TO_SHORT(ctx->Accum.ClearColor[0]);
+         GLshort g = FLOAT_TO_SHORT(ctx->Accum.ClearColor[1]);
+         GLshort b = FLOAT_TO_SHORT(ctx->Accum.ClearColor[2]);
+         GLshort a = FLOAT_TO_SHORT(ctx->Accum.ClearColor[3]);
+         int i, j;
+         for (i = 0; i < height; i++) {
+            GLshort *dst = (GLshort *) (data + (ypos + i) * stride + xpos * 8);
+            for (j = 0; j < width; j++) {
+               dst[0] = r;
+               dst[1] = g;
+               dst[2] = b;
+               dst[3] = a;
+               dst += 4;
+            }
+         }
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "unexpected format in st_clear_accum_buffer()");
+   }
+}
+
+
+/** For ADD/MULT */
+static void
+accum_mad(struct gl_context *ctx, GLfloat scale, GLfloat bias,
+          GLint xpos, GLint ypos, GLint width, GLint height,
+          struct st_renderbuffer *acc_strb)
+{
+   size_t stride = acc_strb->stride;
+   GLubyte *data = acc_strb->data;
+
+   switch (acc_strb->format) {
+   case PIPE_FORMAT_R16G16B16A16_SNORM:
+      {
+         int i, j;
+         for (i = 0; i < height; i++) {
+            GLshort *acc = (GLshort *) (data + (ypos + i) * stride + xpos * 8);
+            for (j = 0; j < width * 4; j++) {
+               float val = SHORT_TO_FLOAT(*acc) * scale + bias;
+               *acc++ = FLOAT_TO_SHORT(val);
+            }
+         }
+      }
+      break;
+   default:
+      _mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");
+   }
+}
+
+
+static void
+accum_accum(struct st_context *st, GLfloat value,
+            GLint xpos, GLint ypos, GLint width, GLint height,
+            struct st_renderbuffer *acc_strb,
+            struct st_renderbuffer *color_strb)
+{
+   struct pipe_context *pipe = st->pipe;
+   struct pipe_transfer *color_trans;
+   size_t stride = acc_strb->stride;
+   GLubyte *data = acc_strb->data;
+   GLfloat *buf;
+
+   if (ST_DEBUG & DEBUG_FALLBACK)
+      debug_printf("%s: fallback processing\n", __FUNCTION__);
+
+   color_trans = pipe_get_transfer(st->pipe,
+                                   color_strb->texture,
+                                   0, 0,
+                                   PIPE_TRANSFER_READ, xpos, ypos,
+                                   width, height);
+
+   buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
+
+   pipe_get_tile_rgba_format(pipe, color_trans, 0, 0, width, height,
+                             util_format_linear(color_strb->texture->format),
+                             buf);
+
+   switch (acc_strb->format) {
+   case PIPE_FORMAT_R16G16B16A16_SNORM:
+      {
+         const GLfloat *color = buf;
+         int i, j;
+         for (i = 0; i < height; i++) {
+            GLshort *acc = (GLshort *) (data + (ypos + i) * stride + xpos * 8);
+            for (j = 0; j < width * 4; j++) {
+               float val = *color++ * value;
+               *acc++ += FLOAT_TO_SHORT(val);
+            }
+         }
+      }
+      break;
+   default:
+      _mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");
+   }
+
+   free(buf);
+   pipe->transfer_destroy(pipe, color_trans);
+}
+
+
+static void
+accum_load(struct st_context *st, GLfloat value,
+           GLint xpos, GLint ypos, GLint width, GLint height,
+           struct st_renderbuffer *acc_strb,
+           struct st_renderbuffer *color_strb)
+{
+   struct pipe_context *pipe = st->pipe;
+   struct pipe_transfer *color_trans;
+   size_t stride = acc_strb->stride;
+   GLubyte *data = acc_strb->data;
+   GLfloat *buf;
+
+   if (ST_DEBUG & DEBUG_FALLBACK)
+      debug_printf("%s: fallback processing\n", __FUNCTION__);
+
+   color_trans = pipe_get_transfer(st->pipe, color_strb->texture,
+                                   0, 0,
+                                   PIPE_TRANSFER_READ, xpos, ypos,
+                                   width, height);
+
+   buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
+
+   pipe_get_tile_rgba_format(pipe, color_trans, 0, 0, width, height,
+                             util_format_linear(color_strb->texture->format),
+                             buf);
+
+   switch (acc_strb->format) {
+   case PIPE_FORMAT_R16G16B16A16_SNORM:
+      {
+         const GLfloat *color = buf;
+         int i, j;
+         for (i = 0; i < height; i++) {
+            GLshort *acc = (GLshort *) (data + (ypos + i) * stride + xpos * 8);
+            for (j = 0; j < width * 4; j++) {
+               float val = *color++ * value;
+               *acc++ = FLOAT_TO_SHORT(val);
+            }
+         }
+      }
+      break;
+   default:
+      _mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");
+   }
+
+   free(buf);
+   pipe->transfer_destroy(pipe, color_trans);
+}
+
+
+static void
+accum_return(struct gl_context *ctx, GLfloat value,
+             GLint xpos, GLint ypos, GLint width, GLint height,
+             struct st_renderbuffer *acc_strb,
+             struct st_renderbuffer *color_strb)
+{
+   struct pipe_context *pipe = st_context(ctx)->pipe;
+   const GLubyte *colormask = ctx->Color.ColorMask[0];
+   enum pipe_transfer_usage usage;
+   struct pipe_transfer *color_trans;
+   size_t stride = acc_strb->stride;
+   const GLubyte *data = acc_strb->data;
+   GLfloat *buf;
+   enum pipe_format format = util_format_linear(color_strb->texture->format);
+
+   if (ST_DEBUG & DEBUG_FALLBACK)
+      debug_printf("%s: fallback processing\n", __FUNCTION__);
+
+   buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
+
+   if (!colormask[0] || !colormask[1] || !colormask[2] || !colormask[3])
+      usage = PIPE_TRANSFER_READ_WRITE;
+   else
+      usage = PIPE_TRANSFER_WRITE;
+
+   color_trans = pipe_get_transfer(pipe,
+                                   color_strb->texture, 0, 0,
+                                   usage,
+                                   xpos, ypos,
+                                   width, height);
+
+   if (usage & PIPE_TRANSFER_READ)
+      pipe_get_tile_rgba_format(pipe, color_trans, 0, 0, width, height,
+                                format, buf);
+
+   switch (acc_strb->format) {
+   case PIPE_FORMAT_R16G16B16A16_SNORM:
+      {
+         GLfloat *color = buf;
+         int i, j, ch;
+         for (i = 0; i < height; i++) {
+            const GLshort *acc = (const GLshort *) (data + (ypos + i) * stride + xpos * 8);
+            for (j = 0; j < width; j++) {
+               for (ch = 0; ch < 4; ch++) {
+                  if (colormask[ch]) {
+                     GLfloat val = SHORT_TO_FLOAT(*acc * value);
+                     *color = CLAMP(val, 0.0f, 1.0f);
+                  }
+                  else {
+                     /* No change */
+                  }
+                  ++acc;
+                  ++color;
+               }
+            }
+         }
+      }
+      break;
+   default:
+      _mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");
+   }
+
+   pipe_put_tile_rgba_format(pipe, color_trans, 0, 0, width, height,
+                             format, buf);
+
+   free(buf);
+   pipe->transfer_destroy(pipe, color_trans);
+}
+
+
+static void
+st_Accum(struct gl_context *ctx, GLenum op, GLfloat value)
+{
+   struct st_context *st = st_context(ctx);
+   struct st_renderbuffer *acc_strb
+     = st_renderbuffer(ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer);
+   struct st_renderbuffer *color_strb
+      = st_renderbuffer(ctx->ReadBuffer->_ColorReadBuffer);
+
+   const GLint xpos = ctx->DrawBuffer->_Xmin;
+   const GLint ypos = ctx->DrawBuffer->_Ymin;
+   const GLint width = ctx->DrawBuffer->_Xmax - xpos;
+   const GLint height = ctx->DrawBuffer->_Ymax - ypos;
+
+   if(!acc_strb->data)
+      return;
+   
+   switch (op) {
+   case GL_ADD:
+      if (value != 0.0F) {
+         accum_mad(ctx, 1.0, value, xpos, ypos, width, height, acc_strb);
+      }
+      break;
+   case GL_MULT:
+      if (value != 1.0F) {
+         accum_mad(ctx, value, 0.0, xpos, ypos, width, height, acc_strb);
+      }
+      break;
+   case GL_ACCUM:
+      if (value != 0.0F) {
+         accum_accum(st, value, xpos, ypos, width, height, acc_strb, color_strb);
+      }
+      break;
+   case GL_LOAD:
+      accum_load(st, value, xpos, ypos, width, height, acc_strb, color_strb);
+      break;
+   case GL_RETURN:
+      accum_return(ctx, value, xpos, ypos, width, height, acc_strb, color_strb);
+      break;
+   default:
+      assert(0);
+   }
+}
+
+
+
+void st_init_accum_functions(struct dd_function_table *functions)
+{
+   functions->Accum = st_Accum;
+}
+
+#endif /* FEATURE_accum */
diff --git a/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c b/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c
index 1e489b29d..7374bb0ac 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c
@@ -222,8 +222,7 @@ st_bufferobj_data(struct gl_context *ctx,
       }
 
       if (data)
-         pipe_buffer_write(st_context(ctx)->pipe, st_obj->buffer, 0,
-				       size, data);
+         pipe_buffer_write(pipe, st_obj->buffer, 0, size, data);
       return GL_TRUE;
    }
 
diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
index 9948f8d2b..29c1df4ae 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -793,9 +793,10 @@ draw_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
    else
       usage = PIPE_TRANSFER_WRITE;
 
-   pt = pipe_get_transfer(st_context(ctx)->pipe, strb->texture, 0, 0,
-                                     usage, x, y,
-                                     width, height);
+   pt = pipe_get_transfer(pipe, strb->texture,
+                          strb->rtt_level, strb->rtt_face + strb->rtt_slice,
+                          usage, x, y,
+                          width, height);
 
    stmap = pipe_transfer_map(pipe, pt);
 
@@ -1130,8 +1131,10 @@ copy_stencil_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
       dsty = rbDraw->Base.Height - dsty - height;
    }
 
-   ptDraw = pipe_get_transfer(st_context(ctx)->pipe,
-                              rbDraw->texture, 0, 0,
+   ptDraw = pipe_get_transfer(pipe,
+                              rbDraw->texture,
+                              rbDraw->rtt_level,
+                              rbDraw->rtt_face + rbDraw->rtt_slice,
                               usage, dstx, dsty,
                               width, height);
 
@@ -1291,8 +1294,10 @@ blit_copy_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
          u_box_2d(readX, readY, readW, readH, &srcBox);
 
          pipe->resource_copy_region(pipe,
-                                    rbDraw->texture, 0, drawX, drawY, 0,
-                                    rbRead->texture, 0, &srcBox);
+                                    rbDraw->texture,
+                                    rbDraw->rtt_level, drawX, drawY, 0,
+                                    rbRead->texture,
+                                    rbRead->rtt_level, &srcBox);
          return GL_TRUE;
       }
    }
@@ -1444,10 +1449,10 @@ st_CopyPixels(struct gl_context *ctx, GLint srcx, GLint srcy,
       /* copy source framebuffer surface into mipmap/texture */
       pipe->resource_copy_region(pipe,
                                  pt,                                /* dest tex */
-                                 0,
+                                 0,                                 /* dest lvl */
                                  pack.SkipPixels, pack.SkipRows, 0, /* dest pos */
                                  rbRead->texture,                   /* src tex */
-                                 0,
+                                 rbRead->rtt_level,                 /* src lvl */
                                  &src_box);
 
    }
@@ -1455,7 +1460,8 @@ st_CopyPixels(struct gl_context *ctx, GLint srcx, GLint srcy,
       /* CPU-based fallback/conversion */
       struct pipe_transfer *ptRead =
          pipe_get_transfer(st->pipe, rbRead->texture,
-                           0, 0, /* level, layer */
+                           rbRead->rtt_level,
+                           rbRead->rtt_face + rbRead->rtt_slice,
                            PIPE_TRANSFER_READ,
                            readX, readY, readW, readH);
       struct pipe_transfer *ptTex;
diff --git a/mesalib/src/mesa/state_tracker/st_cb_readpixels.c b/mesalib/src/mesa/state_tracker/st_cb_readpixels.c
index 2a63799bd..67926e392 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_readpixels.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_readpixels.c
@@ -82,7 +82,8 @@ st_read_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
    /* Create a read transfer from the renderbuffer's texture */
 
    pt = pipe_get_transfer(pipe, strb->texture,
-                          0, 0,
+                          strb->rtt_level,
+                          strb->rtt_face + strb->rtt_slice,
                           PIPE_TRANSFER_READ,
                           x, y, width, height);
 
@@ -250,7 +251,8 @@ st_fast_readpixels(struct gl_context *ctx, struct st_renderbuffer *strb,
       }
 
       trans = pipe_get_transfer(pipe, strb->texture,
-                                0, 0,
+                                strb->rtt_level,
+                                strb->rtt_face + strb->rtt_slice,
                                 PIPE_TRANSFER_READ,
                                 x, y, width, height);
       if (!trans) {
@@ -445,7 +447,8 @@ st_readpixels(struct gl_context *ctx, GLint x, GLint y, GLsizei width, GLsizei h
 
    /* Create a read transfer from the renderbuffer's texture */
    trans = pipe_get_transfer(pipe, strb->texture,
-                             0, 0,
+                             strb->rtt_level, /* level */
+                             strb->rtt_face + strb->rtt_slice, /* layer */
                              PIPE_TRANSFER_READ,
                              x, y, width, height);
 
diff --git a/mesalib/src/mesa/state_tracker/st_cb_texture.c b/mesalib/src/mesa/state_tracker/st_cb_texture.c
index a27c30e51..9d824b46c 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_texture.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_texture.c
@@ -807,7 +807,7 @@ decompress_with_blit(struct gl_context * ctx, GLenum target, GLint level,
                         PIPE_TEX_MIPFILTER_NEAREST);
 
    /* map the dst_surface so we can read from it */
-   tex_xfer = pipe_get_transfer(st_context(ctx)->pipe,
+   tex_xfer = pipe_get_transfer(pipe,
                                 dst_texture, 0, 0,
                                 PIPE_TRANSFER_READ,
                                 0, 0, width, height);
@@ -1228,7 +1228,7 @@ fallback_copy_texsubimage(struct gl_context *ctx, GLenum target, GLint level,
       srcY = strb->Base.Height - srcY - height;
    }
 
-   src_trans = pipe_get_transfer(st_context(ctx)->pipe,
+   src_trans = pipe_get_transfer(pipe,
                                  strb->texture,
                                  0, 0,
                                  PIPE_TRANSFER_READ,
diff --git a/mesalib/src/mesa/state_tracker/st_gen_mipmap.c b/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
index 2c37c1107..b34794f1b 100644
--- a/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
+++ b/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
@@ -1,451 +1,451 @@
-/**************************************************************************

- * 

- * 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.

- * 

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

-

-

-#include "main/imports.h"

-#include "main/mipmap.h"

-#include "main/teximage.h"

-

-#include "pipe/p_context.h"

-#include "pipe/p_defines.h"

-#include "util/u_inlines.h"

-#include "util/u_format.h"

-#include "util/u_gen_mipmap.h"

-

-#include "st_debug.h"

-#include "st_context.h"

-#include "st_texture.h"

-#include "st_gen_mipmap.h"

-#include "st_cb_texture.h"

-

-

-/**

- * one-time init for generate mipmap

- * XXX Note: there may be other times we need no-op/simple state like this.

- * In that case, some code refactoring would be good.

- */

-void

-st_init_generate_mipmap(struct st_context *st)

-{

-   st->gen_mipmap = util_create_gen_mipmap(st->pipe, st->cso_context);

-}

-

-

-void

-st_destroy_generate_mipmap(struct st_context *st)

-{

-   util_destroy_gen_mipmap(st->gen_mipmap);

-   st->gen_mipmap = NULL;

-}

-

-

-/**

- * Generate mipmap levels using hardware rendering.

- * \return TRUE if successful, FALSE if not possible

- */

-static boolean

-st_render_mipmap(struct st_context *st,

-                 GLenum target,

-                 struct st_texture_object *stObj,

-                 uint baseLevel, uint lastLevel)

-{

-   struct pipe_context *pipe = st->pipe;

-   struct pipe_screen *screen = pipe->screen;

-   struct pipe_sampler_view *psv = st_get_texture_sampler_view(stObj, pipe);

-   const uint face = _mesa_tex_target_to_face(target);

-

-   assert(psv->texture == stObj->pt);

-#if 0

-   assert(target != GL_TEXTURE_3D); /* implemented but untested */

-#endif

-

-   /* check if we can render in the texture's format */

-   /* XXX should probably kill this and always use util_gen_mipmap

-      since this implements a sw fallback as well */

-   if (!screen->is_format_supported(screen, psv->format, psv->texture->target,

-                                    0, PIPE_BIND_RENDER_TARGET)) {

-      return FALSE;

-   }

-

-   util_gen_mipmap(st->gen_mipmap, psv, face, baseLevel, lastLevel,

-                   PIPE_TEX_FILTER_LINEAR);

-

-   return TRUE;

-}

-

-

-/**

- * Helper function to decompress an image.  The result is a 32-bpp RGBA

- * image with stride==width.

- */

-static void

-decompress_image(enum pipe_format format, int datatype,

-                 const uint8_t *src, void *dst,

-                 unsigned width, unsigned height, unsigned src_stride)

-{

-   const struct util_format_description *desc = util_format_description(format);

-   const uint bw = util_format_get_blockwidth(format);

-   const uint bh = util_format_get_blockheight(format);

-   uint dst_stride = 4 * MAX2(width, bw);

-

-   if (datatype == GL_FLOAT) {

-      desc->unpack_rgba_float((float *)dst, dst_stride * sizeof(GLfloat), src, src_stride, width, height);

-      if (width < bw || height < bh) {

-	 float *dst_p = (float *)dst;

-	 /* We're decompressing an image smaller than the compression

-	  * block size.  We don't want garbage pixel values in the region

-	  * outside (width x height) so replicate pixels from the (width

-	  * x height) region to fill out the (bw x bh) block size.

-	  */

-	 uint x, y;

-	 for (y = 0; y < bh; y++) {

-	    for (x = 0; x < bw; x++) {

-	       if (x >= width || y >= height) {

-		  uint p = (y * bw + x) * 4;

-		  dst_p[p + 0] = dst_p[0];

-		  dst_p[p + 1] = dst_p[1];

-		  dst_p[p + 2] = dst_p[2];

-		  dst_p[p + 3] = dst_p[3];

-	       }

-	    }

-	 }

-      }

-   } else {

-      desc->unpack_rgba_8unorm((uint8_t *)dst, dst_stride, src, src_stride, width, height);

-      if (width < bw || height < bh) {

-	 uint8_t *dst_p = (uint8_t *)dst;

-	 /* We're decompressing an image smaller than the compression

-	  * block size.  We don't want garbage pixel values in the region

-	  * outside (width x height) so replicate pixels from the (width

-	  * x height) region to fill out the (bw x bh) block size.

-	  */

-	 uint x, y;

-	 for (y = 0; y < bh; y++) {

-	    for (x = 0; x < bw; x++) {

-	       if (x >= width || y >= height) {

-		  uint p = (y * bw + x) * 4;

-		  dst_p[p + 0] = dst_p[0];

-		  dst_p[p + 1] = dst_p[1];

-		  dst_p[p + 2] = dst_p[2];

-		  dst_p[p + 3] = dst_p[3];

-	       }

-	    }

-	 }

-      }

-   }

-}

-

-/**

- * Helper function to compress an image.  The source is a 32-bpp RGBA image

- * with stride==width.

- */

-static void

-compress_image(enum pipe_format format, int datatype,

-               const void *src, uint8_t *dst,

-               unsigned width, unsigned height, unsigned dst_stride)

-{

-   const struct util_format_description *desc = util_format_description(format);

-   const uint src_stride = 4 * width;

-

-   if (datatype == GL_FLOAT)

-      desc->pack_rgba_float(dst, dst_stride, (GLfloat *)src, src_stride * sizeof(GLfloat), width, height);

-   else

-      desc->pack_rgba_8unorm(dst, dst_stride, (uint8_t *)src, src_stride, width, height);

-}

-

-

-/**

- * Software fallback for generate mipmap levels.

- */

-static void

-fallback_generate_mipmap(struct gl_context *ctx, GLenum target,

-                         struct gl_texture_object *texObj)

-{

-   struct pipe_context *pipe = st_context(ctx)->pipe;

-   struct pipe_resource *pt = st_get_texobj_resource(texObj);

-   const uint baseLevel = texObj->BaseLevel;

-   const uint lastLevel = pt->last_level;

-   const uint face = _mesa_tex_target_to_face(target);

-   uint dstLevel;

-   GLenum datatype;

-   GLuint comps;

-   GLboolean compressed;

-

-   if (ST_DEBUG & DEBUG_FALLBACK)

-      debug_printf("%s: fallback processing\n", __FUNCTION__);

-

-   assert(target != GL_TEXTURE_3D); /* not done yet */

-

-   compressed =

-      _mesa_is_format_compressed(texObj->Image[face][baseLevel]->TexFormat);

-

-   if (compressed) {

-      GLenum type =

-         _mesa_get_format_datatype(texObj->Image[face][baseLevel]->TexFormat);

-

-      datatype = type == GL_UNSIGNED_NORMALIZED ? GL_UNSIGNED_BYTE : GL_FLOAT;

-      comps = 4;

-   }

-   else {

-      _mesa_format_to_type_and_comps(texObj->Image[face][baseLevel]->TexFormat,

-                                     &datatype, &comps);

-      assert(comps > 0 && "bad texture format in fallback_generate_mipmap()");

-   }

-

-   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {

-      const uint srcLevel = dstLevel - 1;

-      const uint srcWidth = u_minify(pt->width0, srcLevel);

-      const uint srcHeight = u_minify(pt->height0, srcLevel);

-      const uint srcDepth = u_minify(pt->depth0, srcLevel);

-      const uint dstWidth = u_minify(pt->width0, dstLevel);

-      const uint dstHeight = u_minify(pt->height0, dstLevel);

-      const uint dstDepth = u_minify(pt->depth0, dstLevel);

-      struct pipe_transfer *srcTrans, *dstTrans;

-      const ubyte *srcData;

-      ubyte *dstData;

-      int srcStride, dstStride;

-

-      srcTrans = pipe_get_transfer(st_context(ctx)->pipe, pt, srcLevel,

-                                   face,

-                                   PIPE_TRANSFER_READ, 0, 0,

-                                   srcWidth, srcHeight);

-

-      dstTrans = pipe_get_transfer(st_context(ctx)->pipe, pt, dstLevel,

-                                   face,

-                                   PIPE_TRANSFER_WRITE, 0, 0,

-                                   dstWidth, dstHeight);

-

-      srcData = (ubyte *) pipe_transfer_map(pipe, srcTrans);

-      dstData = (ubyte *) pipe_transfer_map(pipe, dstTrans);

-

-      srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->resource->format);

-      dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->resource->format);

-

-     /* this cannot work correctly for 3d since it does

-        not respect layerStride. */

-      if (compressed) {

-         const enum pipe_format format = pt->format;

-         const uint bw = util_format_get_blockwidth(format);

-         const uint bh = util_format_get_blockheight(format);

-         const uint srcWidth2 = align(srcWidth, bw);

-         const uint srcHeight2 = align(srcHeight, bh);

-         const uint dstWidth2 = align(dstWidth, bw);

-         const uint dstHeight2 = align(dstHeight, bh);

-         uint8_t *srcTemp, *dstTemp;

-

-         assert(comps == 4);

-

-         srcTemp = malloc(srcWidth2 * srcHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));

-         dstTemp = malloc(dstWidth2 * dstHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));

-

-         /* decompress the src image: srcData -> srcTemp */

-         decompress_image(format, datatype, srcData, srcTemp, srcWidth2, srcHeight2, srcTrans->stride);

-

-         _mesa_generate_mipmap_level(target, datatype, comps,

-                                     0 /*border*/,

-                                     srcWidth2, srcHeight2, srcDepth,

-                                     srcTemp,

-                                     srcWidth2, /* stride in texels */

-                                     dstWidth2, dstHeight2, dstDepth,

-                                     dstTemp,

-                                     dstWidth2); /* stride in texels */

-

-         /* compress the new image: dstTemp -> dstData */

-         compress_image(format, datatype, dstTemp, dstData, dstWidth2, dstHeight2, dstTrans->stride);

-

-         free(srcTemp);

-         free(dstTemp);

-      }

-      else {

-         _mesa_generate_mipmap_level(target, datatype, comps,

-                                     0 /*border*/,

-                                     srcWidth, srcHeight, srcDepth,

-                                     srcData,

-                                     srcStride, /* stride in texels */

-                                     dstWidth, dstHeight, dstDepth,

-                                     dstData,

-                                     dstStride); /* stride in texels */

-      }

-

-      pipe_transfer_unmap(pipe, srcTrans);

-      pipe_transfer_unmap(pipe, dstTrans);

-

-      pipe->transfer_destroy(pipe, srcTrans);

-      pipe->transfer_destroy(pipe, dstTrans);

-   }

-}

-

-

-/**

- * Compute the expected number of mipmap levels in the texture given

- * the width/height/depth of the base image and the GL_TEXTURE_BASE_LEVEL/

- * GL_TEXTURE_MAX_LEVEL settings.  This will tell us how many mipmap

- * levels should be generated.

- */

-static GLuint

-compute_num_levels(struct gl_context *ctx,

-                   struct gl_texture_object *texObj,

-                   GLenum target)

-{

-   if (target == GL_TEXTURE_RECTANGLE_ARB) {

-      return 1;

-   }

-   else {

-      const struct gl_texture_image *baseImage = 

-         _mesa_get_tex_image(ctx, texObj, target, texObj->BaseLevel);

-      GLuint size, numLevels;

-

-      size = MAX2(baseImage->Width2, baseImage->Height2);

-      size = MAX2(size, baseImage->Depth2);

-

-      numLevels = texObj->BaseLevel;

-

-      while (size > 0) {

-         numLevels++;

-         size >>= 1;

-      }

-

-      numLevels = MIN2(numLevels, texObj->MaxLevel + 1);

-

-      assert(numLevels >= 1);

-

-      return numLevels;

-   }

-}

-

-

-/**

- * Called via ctx->Driver.GenerateMipmap().

- */

-void

-st_generate_mipmap(struct gl_context *ctx, GLenum target,

-                   struct gl_texture_object *texObj)

-{

-   struct st_context *st = st_context(ctx);

-   struct st_texture_object *stObj = st_texture_object(texObj);

-   struct pipe_resource *pt = st_get_texobj_resource(texObj);

-   const uint baseLevel = texObj->BaseLevel;

-   uint lastLevel;

-   uint dstLevel;

-

-   if (!pt)

-      return;

-

-   /* not sure if this ultimately actually should work,

-      but we're not supporting multisampled textures yet. */

-   assert(pt->nr_samples < 2);

-

-   /* find expected last mipmap level to generate*/

-   lastLevel = compute_num_levels(ctx, texObj, target) - 1;

-

-   if (lastLevel == 0)

-      return;

-

-   /* The texture isn't in a "complete" state yet so set the expected

-    * lastLevel here, since it won't get done in st_finalize_texture().

-    */

-   stObj->lastLevel = lastLevel;

-

-   if (pt->last_level < lastLevel) {

-      /* The current gallium texture doesn't have space for all the

-       * mipmap levels we need to generate.  So allocate a new texture.

-       */

-      struct pipe_resource *oldTex = stObj->pt;

-

-      /* create new texture with space for more levels */

-      stObj->pt = st_texture_create(st,

-                                    oldTex->target,

-                                    oldTex->format,

-                                    lastLevel,

-                                    oldTex->width0,

-                                    oldTex->height0,

-                                    oldTex->depth0,

-                                    oldTex->array_size,

-                                    oldTex->bind);

-

-      /* This will copy the old texture's base image into the new texture

-       * which we just allocated.

-       */

-      st_finalize_texture(ctx, st->pipe, texObj);

-

-      /* release the old tex (will likely be freed too) */

-      pipe_resource_reference(&oldTex, NULL);

-      pipe_sampler_view_reference(&stObj->sampler_view, NULL);

-   }

-   else {

-      /* Make sure that the base texture image data is present in the

-       * texture buffer.

-       */

-      st_finalize_texture(ctx, st->pipe, texObj);

-   }

-

-   pt = stObj->pt;

-

-   assert(pt->last_level >= lastLevel);

-

-   /* Try to generate the mipmap by rendering/texturing.  If that fails,

-    * use the software fallback.

-    */

-   if (!st_render_mipmap(st, target, stObj, baseLevel, lastLevel)) {

-      /* since the util code actually also has a fallback, should

-         probably make it never fail and kill this */

-      fallback_generate_mipmap(ctx, target, texObj);

-   }

-

-   /* Fill in the Mesa gl_texture_image fields */

-   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {

-      const uint srcLevel = dstLevel - 1;

-      const struct gl_texture_image *srcImage

-         = _mesa_get_tex_image(ctx, texObj, target, srcLevel);

-      struct gl_texture_image *dstImage;

-      struct st_texture_image *stImage;

-      uint dstWidth = u_minify(pt->width0, dstLevel);

-      uint dstHeight = u_minify(pt->height0, dstLevel);

-      uint dstDepth = u_minify(pt->depth0, dstLevel); 

-      uint border = srcImage->Border;

-

-      dstImage = _mesa_get_tex_image(ctx, texObj, target, dstLevel);

-      if (!dstImage) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");

-         return;

-      }

-

-      /* Free old image data */

-      if (dstImage->Data)

-         ctx->Driver.FreeTexImageData(ctx, dstImage);

-

-      /* initialize new image */

-      _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,

-                                 dstDepth, border, srcImage->InternalFormat,

-                                 srcImage->TexFormat);

-

-      stImage = st_texture_image(dstImage);

-      stImage->level = dstLevel;

-

-      pipe_resource_reference(&stImage->pt, pt);

-   }

-}

+/**************************************************************************
+ * 
+ * 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.
+ * 
+ **************************************************************************/
+
+
+#include "main/imports.h"
+#include "main/mipmap.h"
+#include "main/teximage.h"
+
+#include "pipe/p_context.h"
+#include "pipe/p_defines.h"
+#include "util/u_inlines.h"
+#include "util/u_format.h"
+#include "util/u_gen_mipmap.h"
+
+#include "st_debug.h"
+#include "st_context.h"
+#include "st_texture.h"
+#include "st_gen_mipmap.h"
+#include "st_cb_texture.h"
+
+
+/**
+ * one-time init for generate mipmap
+ * XXX Note: there may be other times we need no-op/simple state like this.
+ * In that case, some code refactoring would be good.
+ */
+void
+st_init_generate_mipmap(struct st_context *st)
+{
+   st->gen_mipmap = util_create_gen_mipmap(st->pipe, st->cso_context);
+}
+
+
+void
+st_destroy_generate_mipmap(struct st_context *st)
+{
+   util_destroy_gen_mipmap(st->gen_mipmap);
+   st->gen_mipmap = NULL;
+}
+
+
+/**
+ * Generate mipmap levels using hardware rendering.
+ * \return TRUE if successful, FALSE if not possible
+ */
+static boolean
+st_render_mipmap(struct st_context *st,
+                 GLenum target,
+                 struct st_texture_object *stObj,
+                 uint baseLevel, uint lastLevel)
+{
+   struct pipe_context *pipe = st->pipe;
+   struct pipe_screen *screen = pipe->screen;
+   struct pipe_sampler_view *psv = st_get_texture_sampler_view(stObj, pipe);
+   const uint face = _mesa_tex_target_to_face(target);
+
+   assert(psv->texture == stObj->pt);
+#if 0
+   assert(target != GL_TEXTURE_3D); /* implemented but untested */
+#endif
+
+   /* check if we can render in the texture's format */
+   /* XXX should probably kill this and always use util_gen_mipmap
+      since this implements a sw fallback as well */
+   if (!screen->is_format_supported(screen, psv->format, psv->texture->target,
+                                    0, PIPE_BIND_RENDER_TARGET)) {
+      return FALSE;
+   }
+
+   util_gen_mipmap(st->gen_mipmap, psv, face, baseLevel, lastLevel,
+                   PIPE_TEX_FILTER_LINEAR);
+
+   return TRUE;
+}
+
+
+/**
+ * Helper function to decompress an image.  The result is a 32-bpp RGBA
+ * image with stride==width.
+ */
+static void
+decompress_image(enum pipe_format format, int datatype,
+                 const uint8_t *src, void *dst,
+                 unsigned width, unsigned height, unsigned src_stride)
+{
+   const struct util_format_description *desc = util_format_description(format);
+   const uint bw = util_format_get_blockwidth(format);
+   const uint bh = util_format_get_blockheight(format);
+   uint dst_stride = 4 * MAX2(width, bw);
+
+   if (datatype == GL_FLOAT) {
+      desc->unpack_rgba_float((float *)dst, dst_stride * sizeof(GLfloat), src, src_stride, width, height);
+      if (width < bw || height < bh) {
+	 float *dst_p = (float *)dst;
+	 /* We're decompressing an image smaller than the compression
+	  * block size.  We don't want garbage pixel values in the region
+	  * outside (width x height) so replicate pixels from the (width
+	  * x height) region to fill out the (bw x bh) block size.
+	  */
+	 uint x, y;
+	 for (y = 0; y < bh; y++) {
+	    for (x = 0; x < bw; x++) {
+	       if (x >= width || y >= height) {
+		  uint p = (y * bw + x) * 4;
+		  dst_p[p + 0] = dst_p[0];
+		  dst_p[p + 1] = dst_p[1];
+		  dst_p[p + 2] = dst_p[2];
+		  dst_p[p + 3] = dst_p[3];
+	       }
+	    }
+	 }
+      }
+   } else {
+      desc->unpack_rgba_8unorm((uint8_t *)dst, dst_stride, src, src_stride, width, height);
+      if (width < bw || height < bh) {
+	 uint8_t *dst_p = (uint8_t *)dst;
+	 /* We're decompressing an image smaller than the compression
+	  * block size.  We don't want garbage pixel values in the region
+	  * outside (width x height) so replicate pixels from the (width
+	  * x height) region to fill out the (bw x bh) block size.
+	  */
+	 uint x, y;
+	 for (y = 0; y < bh; y++) {
+	    for (x = 0; x < bw; x++) {
+	       if (x >= width || y >= height) {
+		  uint p = (y * bw + x) * 4;
+		  dst_p[p + 0] = dst_p[0];
+		  dst_p[p + 1] = dst_p[1];
+		  dst_p[p + 2] = dst_p[2];
+		  dst_p[p + 3] = dst_p[3];
+	       }
+	    }
+	 }
+      }
+   }
+}
+
+/**
+ * Helper function to compress an image.  The source is a 32-bpp RGBA image
+ * with stride==width.
+ */
+static void
+compress_image(enum pipe_format format, int datatype,
+               const void *src, uint8_t *dst,
+               unsigned width, unsigned height, unsigned dst_stride)
+{
+   const struct util_format_description *desc = util_format_description(format);
+   const uint src_stride = 4 * width;
+
+   if (datatype == GL_FLOAT)
+      desc->pack_rgba_float(dst, dst_stride, (GLfloat *)src, src_stride * sizeof(GLfloat), width, height);
+   else
+      desc->pack_rgba_8unorm(dst, dst_stride, (uint8_t *)src, src_stride, width, height);
+}
+
+
+/**
+ * Software fallback for generate mipmap levels.
+ */
+static void
+fallback_generate_mipmap(struct gl_context *ctx, GLenum target,
+                         struct gl_texture_object *texObj)
+{
+   struct pipe_context *pipe = st_context(ctx)->pipe;
+   struct pipe_resource *pt = st_get_texobj_resource(texObj);
+   const uint baseLevel = texObj->BaseLevel;
+   const uint lastLevel = pt->last_level;
+   const uint face = _mesa_tex_target_to_face(target);
+   uint dstLevel;
+   GLenum datatype;
+   GLuint comps;
+   GLboolean compressed;
+
+   if (ST_DEBUG & DEBUG_FALLBACK)
+      debug_printf("%s: fallback processing\n", __FUNCTION__);
+
+   assert(target != GL_TEXTURE_3D); /* not done yet */
+
+   compressed =
+      _mesa_is_format_compressed(texObj->Image[face][baseLevel]->TexFormat);
+
+   if (compressed) {
+      GLenum type =
+         _mesa_get_format_datatype(texObj->Image[face][baseLevel]->TexFormat);
+
+      datatype = type == GL_UNSIGNED_NORMALIZED ? GL_UNSIGNED_BYTE : GL_FLOAT;
+      comps = 4;
+   }
+   else {
+      _mesa_format_to_type_and_comps(texObj->Image[face][baseLevel]->TexFormat,
+                                     &datatype, &comps);
+      assert(comps > 0 && "bad texture format in fallback_generate_mipmap()");
+   }
+
+   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
+      const uint srcLevel = dstLevel - 1;
+      const uint srcWidth = u_minify(pt->width0, srcLevel);
+      const uint srcHeight = u_minify(pt->height0, srcLevel);
+      const uint srcDepth = u_minify(pt->depth0, srcLevel);
+      const uint dstWidth = u_minify(pt->width0, dstLevel);
+      const uint dstHeight = u_minify(pt->height0, dstLevel);
+      const uint dstDepth = u_minify(pt->depth0, dstLevel);
+      struct pipe_transfer *srcTrans, *dstTrans;
+      const ubyte *srcData;
+      ubyte *dstData;
+      int srcStride, dstStride;
+
+      srcTrans = pipe_get_transfer(pipe, pt, srcLevel,
+                                   face,
+                                   PIPE_TRANSFER_READ, 0, 0,
+                                   srcWidth, srcHeight);
+
+      dstTrans = pipe_get_transfer(pipe, pt, dstLevel,
+                                   face,
+                                   PIPE_TRANSFER_WRITE, 0, 0,
+                                   dstWidth, dstHeight);
+
+      srcData = (ubyte *) pipe_transfer_map(pipe, srcTrans);
+      dstData = (ubyte *) pipe_transfer_map(pipe, dstTrans);
+
+      srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->resource->format);
+      dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->resource->format);
+
+     /* this cannot work correctly for 3d since it does
+        not respect layerStride. */
+      if (compressed) {
+         const enum pipe_format format = pt->format;
+         const uint bw = util_format_get_blockwidth(format);
+         const uint bh = util_format_get_blockheight(format);
+         const uint srcWidth2 = align(srcWidth, bw);
+         const uint srcHeight2 = align(srcHeight, bh);
+         const uint dstWidth2 = align(dstWidth, bw);
+         const uint dstHeight2 = align(dstHeight, bh);
+         uint8_t *srcTemp, *dstTemp;
+
+         assert(comps == 4);
+
+         srcTemp = malloc(srcWidth2 * srcHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));
+         dstTemp = malloc(dstWidth2 * dstHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));
+
+         /* decompress the src image: srcData -> srcTemp */
+         decompress_image(format, datatype, srcData, srcTemp, srcWidth2, srcHeight2, srcTrans->stride);
+
+         _mesa_generate_mipmap_level(target, datatype, comps,
+                                     0 /*border*/,
+                                     srcWidth2, srcHeight2, srcDepth,
+                                     srcTemp,
+                                     srcWidth2, /* stride in texels */
+                                     dstWidth2, dstHeight2, dstDepth,
+                                     dstTemp,
+                                     dstWidth2); /* stride in texels */
+
+         /* compress the new image: dstTemp -> dstData */
+         compress_image(format, datatype, dstTemp, dstData, dstWidth2, dstHeight2, dstTrans->stride);
+
+         free(srcTemp);
+         free(dstTemp);
+      }
+      else {
+         _mesa_generate_mipmap_level(target, datatype, comps,
+                                     0 /*border*/,
+                                     srcWidth, srcHeight, srcDepth,
+                                     srcData,
+                                     srcStride, /* stride in texels */
+                                     dstWidth, dstHeight, dstDepth,
+                                     dstData,
+                                     dstStride); /* stride in texels */
+      }
+
+      pipe_transfer_unmap(pipe, srcTrans);
+      pipe_transfer_unmap(pipe, dstTrans);
+
+      pipe->transfer_destroy(pipe, srcTrans);
+      pipe->transfer_destroy(pipe, dstTrans);
+   }
+}
+
+
+/**
+ * Compute the expected number of mipmap levels in the texture given
+ * the width/height/depth of the base image and the GL_TEXTURE_BASE_LEVEL/
+ * GL_TEXTURE_MAX_LEVEL settings.  This will tell us how many mipmap
+ * levels should be generated.
+ */
+static GLuint
+compute_num_levels(struct gl_context *ctx,
+                   struct gl_texture_object *texObj,
+                   GLenum target)
+{
+   if (target == GL_TEXTURE_RECTANGLE_ARB) {
+      return 1;
+   }
+   else {
+      const struct gl_texture_image *baseImage = 
+         _mesa_get_tex_image(ctx, texObj, target, texObj->BaseLevel);
+      GLuint size, numLevels;
+
+      size = MAX2(baseImage->Width2, baseImage->Height2);
+      size = MAX2(size, baseImage->Depth2);
+
+      numLevels = texObj->BaseLevel;
+
+      while (size > 0) {
+         numLevels++;
+         size >>= 1;
+      }
+
+      numLevels = MIN2(numLevels, texObj->MaxLevel + 1);
+
+      assert(numLevels >= 1);
+
+      return numLevels;
+   }
+}
+
+
+/**
+ * Called via ctx->Driver.GenerateMipmap().
+ */
+void
+st_generate_mipmap(struct gl_context *ctx, GLenum target,
+                   struct gl_texture_object *texObj)
+{
+   struct st_context *st = st_context(ctx);
+   struct st_texture_object *stObj = st_texture_object(texObj);
+   struct pipe_resource *pt = st_get_texobj_resource(texObj);
+   const uint baseLevel = texObj->BaseLevel;
+   uint lastLevel;
+   uint dstLevel;
+
+   if (!pt)
+      return;
+
+   /* not sure if this ultimately actually should work,
+      but we're not supporting multisampled textures yet. */
+   assert(pt->nr_samples < 2);
+
+   /* find expected last mipmap level to generate*/
+   lastLevel = compute_num_levels(ctx, texObj, target) - 1;
+
+   if (lastLevel == 0)
+      return;
+
+   /* The texture isn't in a "complete" state yet so set the expected
+    * lastLevel here, since it won't get done in st_finalize_texture().
+    */
+   stObj->lastLevel = lastLevel;
+
+   if (pt->last_level < lastLevel) {
+      /* The current gallium texture doesn't have space for all the
+       * mipmap levels we need to generate.  So allocate a new texture.
+       */
+      struct pipe_resource *oldTex = stObj->pt;
+
+      /* create new texture with space for more levels */
+      stObj->pt = st_texture_create(st,
+                                    oldTex->target,
+                                    oldTex->format,
+                                    lastLevel,
+                                    oldTex->width0,
+                                    oldTex->height0,
+                                    oldTex->depth0,
+                                    oldTex->array_size,
+                                    oldTex->bind);
+
+      /* This will copy the old texture's base image into the new texture
+       * which we just allocated.
+       */
+      st_finalize_texture(ctx, st->pipe, texObj);
+
+      /* release the old tex (will likely be freed too) */
+      pipe_resource_reference(&oldTex, NULL);
+      pipe_sampler_view_reference(&stObj->sampler_view, NULL);
+   }
+   else {
+      /* Make sure that the base texture image data is present in the
+       * texture buffer.
+       */
+      st_finalize_texture(ctx, st->pipe, texObj);
+   }
+
+   pt = stObj->pt;
+
+   assert(pt->last_level >= lastLevel);
+
+   /* Try to generate the mipmap by rendering/texturing.  If that fails,
+    * use the software fallback.
+    */
+   if (!st_render_mipmap(st, target, stObj, baseLevel, lastLevel)) {
+      /* since the util code actually also has a fallback, should
+         probably make it never fail and kill this */
+      fallback_generate_mipmap(ctx, target, texObj);
+   }
+
+   /* Fill in the Mesa gl_texture_image fields */
+   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
+      const uint srcLevel = dstLevel - 1;
+      const struct gl_texture_image *srcImage
+         = _mesa_get_tex_image(ctx, texObj, target, srcLevel);
+      struct gl_texture_image *dstImage;
+      struct st_texture_image *stImage;
+      uint dstWidth = u_minify(pt->width0, dstLevel);
+      uint dstHeight = u_minify(pt->height0, dstLevel);
+      uint dstDepth = u_minify(pt->depth0, dstLevel); 
+      uint border = srcImage->Border;
+
+      dstImage = _mesa_get_tex_image(ctx, texObj, target, dstLevel);
+      if (!dstImage) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");
+         return;
+      }
+
+      /* Free old image data */
+      if (dstImage->Data)
+         ctx->Driver.FreeTexImageData(ctx, dstImage);
+
+      /* initialize new image */
+      _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,
+                                 dstDepth, border, srcImage->InternalFormat,
+                                 srcImage->TexFormat);
+
+      stImage = st_texture_image(dstImage);
+      stImage->level = dstLevel;
+
+      pipe_resource_reference(&stImage->pt, pt);
+   }
+}